Please use your reply to this blog post to detail the following:
- Please start with a full description of the nature of your first ML project.
- What was your primary motivation to explore the project you completed?
- Share some insights into what predictions you were able to make on the dataset you used for your project.
- What new skills did you pick up from this project? For example, if you used Jupyter Notebooks, had you used that technology before? Did you encounter any weird bugs, twists, or turns in your dataset that caused issues? How did you resolve those issues?
- What was the most challenging part of mining and refining your dataset (while you’re at it, you should talk about where you got or mined your dataset, if you connected to an API)?
- What types of conclusions can you derive from the images/graphs you created with your project? If you didn’t create charts or graphs and instead explored things like Markov Chains, how much work do you think you need to do to further refine your project to make its output more realistic?
- Given your experience with this project, if you had the opportunity to do anything for your next ML enterprise, what would you explore? Would you try to market your findings and sell them? Why or why not?
Take the time to look through the project posts of your classmates. You don’t have to comment on the posts of your classmates, but if you want to give them praise or just comment on their project if you found it cool, please do.
1.
I built a model that used the 2026 MLB regular season to predict the 2026 playoffs as they happened. It predicts who wins each game, then uses those predictions to play out every playoff series. I saved each prediction to GitHub before the games were played, so I couldn’t cheat with hindsight. My final model looks at three things: each team’s run differential, its last 10 games, and its starting pitchers.
2.
I love playing and watching baseball, so this was a chance to use computer science on something I really care about. The playoffs also started the same day I started the project, so I could make real predictions and see if they came true.
3.
My model’s best call was picking the Rays to beat the Guardians in 6 games, which is exactly what happened. It also picked the Brewers to beat the Dodgers, and the Brewers swept them. For the World Series, my model picks the Brewers in 6. I also compared my model with a betting market: the market’s favorite was the Dodgers, but my model liked the Brewers more.
4.
I learned how to pull data from a live API, train a model with scikit-learn, run simulations, and build a display with Pygame. My biggest bug was a game that MLB listed twice because it was suspended and finished the next day. I found it because my data had extra rows, and I fixed it so the game only counted once. I also had to install a package correctly before my code would run at all.
5.
All my data came from MLB’s official API: every regular-season game, plus the starting pitchers for each one. The hardest part was making sure the model only used information from before each game, so it couldn’t “see the future.” I also had to deal with early-season stats being mostly luck, since a team that starts 3–0 isn’t really perfect.
6.
My graphs showed that adding starting pitchers made the model better in 4 of 5 months, especially late in the season. They also showed that baseball is very random: even good models only predict about 58% of games correctly. My model mostly agreed with the betting market, except about the Dodgers and Brewers.
7.
Next, I’d add more seasons of data and more stats, like bullpen quality. I wouldn’t try to sell it yet, because one good postseason doesn’t prove my model can beat the betting market, which knows things my model doesn’t, like injuries.
1.
I created a polynomial regression model that can work with any relationship between two variables. It imports a list of input data and answer data from a csv file. The model predicts an output, then a loss value is calculated. The derivative of the loss is then taken with respect to each weight of the polynomial terms. The weights are adjusted based on which direction decreases the loss and proportional to the learning rate. This process repeats until the user-set limit is reached or all outputs are predicted within a user-defined threshold. Additionally, I added a function to find the best learning rate. It starts with a specified learning rate and changes it a number of times. It does this until either of the stop conditions are met. For each of the learning rates, it takes the average number of steps(updating all weights once) that it took some number of trials each to find the solution. That average step is then compared to the other learning rates and the best one is selected as the best learning rate. All output displays in the console, clearly indicating if the model predictions are close to the actual answers and the percent error. If graphed you are able to fit the polynomial curve to fit the data. After the deadline I wanted to keep working so I added a UI that more easily allows the user to set parameters.
2.
My primary motivation was to intuitively understand the underlying concepts of how AI works. I only used AI to assist in debugging and small sections, however all the core AI logic I did manually.
3.
For my testing I used housing data, but the model can be used on anything else. I just used the population and median housing price and had the model fit that data. A polynomial model isn’t best for this dataset because it has so much spread, but it still has the general trend and with fewer data points gets very close to matching. Currently it can predict the average median housing price based on population and it shows that it has some correlation, but only is not the main factor.
4.
I’ve never imported data in python from a csv. I’ve also never made functional AI. I’ve also never used derivatives in a programming context which came with a number of bugs since I was trying to do it with a symbolic derivative calculator. Later I found it best to manually find the derivative equations first so they don’t need to be found every time.
5.
I got the dataset from Kaggle and it was easy to download, I mostly had to get used to the pandas library and syntax for grabbing the specific data I wanted.
6.
I think its output is fairly realistic. It just needs data that only has two variables, one independent and one dependent. The graphs it plotted showed its predictions following the general trend of the data. I think it could definitely be refined for efficiency and speed. It would also be interesting to have multiple of these models as nodes connected together into a network.
7.
I think I would want to make something related to robotics, howeverI wouldn’t want to sell my findings if it was going to be used for bad purposes. Creating an AI model that could convert an AI network to equations and a human-readable hardcoded system would be really useful and is probably what I would work toward.
1. I created a K-Pop view count predictor for videos using the YouTube API (data was pulled 10.06.2026). The data comes from 26 official group channels (e.g. BTS, Blackpink, Twice, etc.) and labels (e.g. Hybe, SM, JYP). The model uses a random forest of 100 trees with leaf size 5, meaning it has 100 decision trees (asking yes/no questions like “Is it a MV?”) where each node has 5 data samples; the prediction is taken from the average of the trees. The leaf size minimizes the noise of the prediction because it forces each endpoint to have at least 5 samples. This model resulted in an R2 of 0.711 and mean average error of 0.268, though I also created a 300 tree / leaf size 1 model that scored 0.741. This comes together in the local interface that uses Streamlit and allows the user to input the group, title of the video, type of video (e.g. MV, behind the scenes, short, etc.), release date and time, length, and the time period you’re counting views. The interface will show the predicted amount of views, the 80% range of predictions, and comparisons with other types of videos from the same group.
2. I enjoy listening to K-Pop and was curious about what the logistics of a group might be; for example, what do marketers look at to determine the success of a new comeback song? Of course, my model is certainly a lot more rudimentary than whatever actual labels use, but I thought the idea of attaching numbers to the popularity and virality of the videos was interesting.
3. The three most important factors were the channel’s earlier performance, then video type, and the channel itself. This is less a referendum on what makes videos more popular, but what weights the model used; however, this suggests that already well-known groups are often guaranteed a higher minimum amount of views regardless of the “quality” of the videos. Of course, music videos tend to get more views than shorts or teasers. Since the culture of K-Pop is about sticking with a small selection of groups, it may be that there is a loyal fanbase for each group that ensures videos get consistent views.
The predictions were best for behind the scenes videos and shorts due to the large quantity of them and the relatively consistent viewership; in contrast, music videos were limited in the data set and the model struggled to account for mega hits with hundreds of millions of views (ex. How You Like That by Blackpink). The error for behind the scenes was 0.19, while the model underestimated by up to 7x for the most viewed music videos. The typical error overall was about 1.9x.
4. A skill I practiced was categorizing data. Pulling the data from the YouTube API on its own isn’t very helpful in predicting the view count for a given video on a K-Pop group’s channel because long-form blogs or shorts will skew the view counts down from the much more viral music videos. To account for this, I had to categorize the videos into types like music video, behind the scenes, shorts, dance practice, etc. This was difficult because there is no standard format for these, and the only piece of data that can really help determine this is the title (with clues like “M/V”, “mv”, “MV”, etc.). While length of the video may also help, it’s not entirely reliable. This issue got worse when I added the label channels as well, since those channels tend to also have many videos not related to any particular group that may be read as a music video (or any other type) when it isn’t. I ended up creating a separate list of accepted groups and filtered out non-groups and non-K-Pop groups (like J-Pop collaborations). This method helped especially with the interface since the app pulls from the list of accepted groups, though it may also have artificially limited the data because what counts as a particular video type isn’t clear cut.
5. The most difficult part of mining and refining the dataset was distinguishing between labels and channels. A lot of K-Pop groups publish videos jointly with their label’s official channel, which creates duplicates in the data because I pulled from each channel individually using the YouTube API. The issue with the labels is that they also have videos that the individual group channels don’t have, which also makes it harder to categorize whether a series of videos on a label is about a group or something else. For example, after one of the initial cleanups there were a bunch of “groups” that the model was counting that weren’t actual groups but the names of series and podcasts the label was running. My solution was to A) require there to be a minimum number of videos with the group name in it and B) to create a list of accepted groups/artists to filter out the mistakes. As a result, the model isn’t built on all the possible groups that a label may own and there may still be mistakes in the categorization.
6. The graphs tell us a couple things. For example, the median views by video type graph shows that music videos by far get the highest median views out of any video type; this was expected given that music videos are the main release for a new song, especially on YouTube (in contrast, Spotify doesn’t really have videos of any sort). The views per day by release year graph suggests that new videos collect views more quickly; however, this does not mean smaller groups like Hearts2Hearts are more popular than larger ones like BTS, only that newer groups’ median is inflated because they’re new. The feature importance graph shows that earlier performance, video type, and channel have the most predictive weight, though some features like “has Korean text in the title” may overlap with channel name. Of course, the graphs can only show correlations—not cause and effect—and in the case of feature importance don’t account for the hype or viral trends that surround a release.
7. I would do a similar project that instead focuses on the qualities of a K-Pop song to predict its streams. This would entail using data about the tempo, beats, styles, dances, etc. but also data similar to what I used in this project like a group’s previous performance. The project would differ in that it doesn’t look at any other type of content besides songs themselves (so no teasers, behind the scenes, shorts, etc.) but it would look at non-comeback songs and songs without music videos (like B-lists). There’d be no downside to trying to market it, though I imagine there’s not many people who are curious about this for commercial reasons and don’t already have some model.
For my first machine learning project, I built a distributed, tiny Large Language Model running across a chain of ESP32 S3 microcontrollers. Instead of relying on cloud servers or massive GPUs, I trained it from scratch to act as a Gordon Ramsay impersonator that roasts your code. When you run into an error in your IDE, you prompt the microcontroller chain with it, and it responds with a brutal insult about your programming skills.
My primary motivation was a mix of wanting to push the limits of edge hardware and making debugging a bit more entertaining. Staring at compiler errors all day gets frustrating, so I thought it would be funny if my hardware yelled at me like a frustrated chef whenever I missed a semicolon or caused a crash. I also found it interesting cramming a custom trained LLM onto microcontrollers that cost just a few dollars each felt like a challenge to understand how transformers and quantization work.
I did not use a pre packaged dataset like TinyStories (even though some template files were left in the branch). instead, I built and mined my own dataset and trained the model locally. In the context of LLMs, predictions involve forecasting the next token in a sequence based on prompt context. Once trained on my custom dataset of IDE errors and ramsay style rants, feeding the ESP32 chain a prompt like a SyntaxError or a NullPointerException makes the microcontrollers predict and string together a custom roast.
I picked up several new skills along the way by bridging Pythonbased ML training and C/C++ embedded systems. The first was local LLM training and quantization. I trained an LLM locally on my device using my custom dataset and quantized the weights so they could fit into the ESP32’s flash memory and PSRAM. The second one was UART configuration. I used UART serial communication to link multiple microprocessors together, creating a custom setup where each board handles a piece of the neural network. Lastly, i used embedded memory management. I managed memory manually using ESP IDF and CMake, dealing with raw byte arrays and pointers to fit model weights onto constrained hardware.
The most challenging part of mining and refining the dataset was gathering enough consistent training pairs without the model just memorizing a few catchphrases. Since there is no public API for Gordon Ramsay code roasts, I had to curate real IDE error logs paired with insults myself. Early versions of the dataset caused the model to loop or lose context because of the compression limits, which I fixed by cleaning up the training data formatting, adjusting response lengths, and changing inference parameters. On the hardware side, UART synchronization was really hard to get right. if one ESP32 sent data faster than the next could read it, the buffer would overflow and corrupt the output. I resolved this by tuning baud rates and implementing a protocol between the boards.
Because this was a text generation and hardware project, I did not generate traditional data science graphs, focusing instead on the text output itself. While using a transformer architecture is a massive step up from a Markov Chain because it uses attention mechanisms to understand context, the output still needs refinement to become more realistic. It needs to be more Intelligent, due to memory constraints on microcontrollers, the model’s vocabulary and reasoning are limited. Moving to 4 bit quantization and expanding the dataset with thousands more compiler errors would allow for a smarter model in the same footprint.
Given this experience, for my next ML project, I would use larger microprocessors to fit bigger models and build a complete standalone hardware project, which could be a desktop debugging buddy sitting by the monitor with a small speaker that automatically reads IDE output and roasts failed builds in real time.
I would also try to market these ideas because fitting an LLM on a microcontroller is a unique niche with big potential. Running completely offline, costing pennies to power, and requiring no cloud subscription opens up possibilities for novelty developer gadgets, smart interactive toys, or offline smart home voice assistants.