Machine Learning

Mon, 13 Oct 2025 00:00:00 +0000

Machine Learning Study Log: Teaching a Computer with Data

As I entered the fall semester of my junior year, I began taking a course called “Machine Learning”. I’m attending Professor Song Hyun-je’s lectures every Monday and Wednesday at 4:00 PM in Room 523 of Engineering Building 7. You can find more information on Professor Song Hyun-je’s site via the link attached above!

At first, the term “Machine Learning” felt very difficult and complex. However, now that I’ve started learning it, I’ve realized it’s a fascinating technology that is much closer to our daily lives than I expected. I’ve decided to summarize the basic ML concepts I’ve learned in my own simple words.

🧐 So, what is Machine Learning? My understanding is that machine learning starts with a very simple idea. Instead of explicitly telling a computer every single rule (e.g., “this is an apple,” “this is an orange”), it is a technology that lets the computer learn patterns and rules on its own by showing it vast amounts of data.

It’s similar to how a young child might look at hundreds of pictures of dogs and come to realize on their own, “Ah, an animal with perky ears and fluffy fur is a dog!”

📚 Two Learning Methods I’ve Learned There are many types of machine learning, but I have learned about the two most representative methods.

Teaching with the “Answer Key”: Supervised Learning Supervised learning is, as the name suggests, a method of training a computer using data that already has the “answer” (known as a Label). It works by repeatedly showing the computer sets of “problems” and “answers” together.

A spam filter is a classic example. By training the model on countless emails (problems) labeled as “this is spam” (answer) or “this is important” (answer), it eventually learns to classify new, unseen emails on its own.

Housing price prediction is another example. If it learns from vast amounts of housing data (problems) like, “A 3-bedroom house in Area A costs $500,000” (answer), it will be able to predict the price when given information about a new house.

Letting it Learn on its Own: Unsupervised Learning Unsupervised learning is like giving the computer raw data without any answers and telling it, “Find some meaningful groups or structures within this!” The computer analyzes the features of the data and groups similar items together by itself.

This is very useful for customer management. By feeding it customer purchase pattern data, the model can discover hidden customer segments, such as a “budget shopper group” or a “new product enthusiast group.”

News article clustering is another great example. When given thousands of news articles, the AI can automatically bundle them into similar topics like “Politics,” “Economy,” or “Sports.”

✨ Closing Thoughts Now that I’ve learned the concepts firsthand, I feel that machine learning isn’t some vague, abstract technology, but rather a very logical tool for solving problems. Of course, I still only know the absolute basics, but I find the process of discovering meaning within data to be truly fascinating. I’ve now set a goal for myself to study this more deeply and to try and build a simple project of my own.

Pacman

Sat, 01 Mar 2025 00:00:00 +0000

This is the UC Berkeley Pacman AI project I completed as part of my Artificial Intelligence and Data Structures coursework. The core objective of this assignment was to implement fundamental Graph Search algorithms from scratch and apply them to solve tangible problems within the Pacman game environment.

My work involved implementing generic search algorithms in search.py and defining/solving specific Pacman problems in searchAgents.py.

1. Core Search Algorithm Implementation (search.py)

First, I implemented four fundamental search algorithms that can be applied to any search problem.

DFS (Depth-First Search): Using a Stack, this algorithm explores nodes as deeply as possible first. It was implemented as a graph search, using an explored list to prevent cycles.
BFS (Breadth-First Search): Using a Queue, this algorithm explores the shallowest (closest) nodes first. It guarantees the shortest path when all edge costs are uniform.
UCS (Uniform Cost Search): Using a PriorityQueue, this algorithm prioritizes nodes by their total cumulative ‘cost’. It always explores the path with the lowest cost first, guaranteeing the shortest cost path.
A* (A-Star) Search: Also uses a PriorityQueue, but its priority is the sum of the ‘cumulative cost to date’ ($g(n)$) and an ’estimated cost to the goal’ (heuristic, $h(n)$). This function is $f(n) = g(n) + h(n)$. As an informed search, it finds the optimal solution far more efficiently than UCS.

2. Defining and Solving Pacman Problems (searchAgents.py)

Beyond just implementing the algorithms, I modeled complex problems Pacman faces as formal ‘search problems’ and solved them.

📍 The Corners Problem (CornersProblem) The challenge is to find a path for Pacman to visit all four corners of the map.

State Definition: To solve this, the state space couldn’t just be (x, y). I defined the state as (currentPosition, (visitedCornersTuple)). For example, a state might be ((5, 5), (True, False, False, True)), tracking both the position and the visit-status of each corner.
Goal Definition: The goal state is reached when all boolean values in the tuple state[1] are True.
Successor Function: As Pacman moves, the function checks if the new position is one of the corners. If it is, it generates a new state with the corresponding boolean in the tuple updated to True.

💡 Corners Problem Heuristic (cornersHeuristic)

I designed a heuristic for solving the Corners Problem using A* search.

Design: A heuristic must be admissible (never overestimates the true cost).
Logic: The function calculates the Manhattan Distance from the ‘current position’ to ’every unvisited corner’. It then returns the maximum (max) value among these distances.
Justification: This is admissible because Pacman must travel at least as far as the farthest remaining corner to complete the goal. This value serves as a safe lower bound on the true remaining cost.

🍔 All Food Heuristic (foodHeuristic)

This heuristic was for the FoodSearchProblem, which involves finding a path to eat all the food dots on the map.

Logic: Similar to the corners heuristic, I calculated the actual maze distance (mazeDistance) from the ‘current position’ to ’every remaining food dot’ and returned the maximum (max) value.
Using mazeDistance: Unlike Manhattan distance, mazeDistance is a helper function that runs a BFS to find the true shortest path considering walls, providing a much more accurate (and still admissible) estimate.

🎯 Closest Dot Search Agent

Finding a path to eat all food is very complex (NP-hard). Therefore, I implemented a greedy algorithm that repeatedly finds and eats the closest food dot.

findPathToClosestDot Implementation: I defined a sub-problem called AnyFoodSearchProblem (where the goal is to reach any single food dot).
Using UCS: I applied UCS to this sub-problem. This finds the path to the food dot with the lowest cost (i.e., the closest dot). (Since costs are uniform, BFS would also have guaranteed the same result).

Python | 정진영의 포트폴리오

Machine Learning