Oscar voting is secret, but winners tend to share traits like commercial success, critical acclaim and multiple nominations. My group partner and I trained 3 machine learning models on every Oscar nomination since the awards began, then tested them against the 2026 ceremony.
Group project. Made with my group partner as our DS340 (Introduction to Machine Learning and AI) final project, Boston University, May 2026.
Built with
Language
Python
Neural network
PyTorch
Random forest and logistic regression
scikit-learn
Data
Kaggle (Oscar awards and TMDB)
The Question
Class imbalanceWhen one outcome is much rarer than the other. In a category, there can be up to nine losers for every winner, so a model can look accurate just by always guessing 'no win'. It's why we judged the models on more than accuracy.
We were intrigued by the different features that decide an Oscar. At the end of the day, it comes down to subjective human voting, and the results are heavily imbalanced because most nominees lose. Voters also weigh prestige against commercial success.
So we set out to answer two questions. Can machine learning pick up on the patterns that Oscar winners share? And would those patterns hold up at the 2026 ceremony?
From our final presentation.
Methods
We combined two Kaggle datasets, 11,110 Oscar nominations and over a million films from TMDB, into one table of films and their features.
Joined the Oscar awards data to TMDB's film data on title and year, keeping 1927 to 2024.
Built 94 features, including nomination flags, genres, budget, revenue and ratings.
Trained 3 models, a neural network, a random forest and a logistic regression model, on a 70/15/15 split of the data.
Tested all 3 models on films they had never seen, then on 20 films from the 2026 Oscars.
The Data
Feature engineeringTurning raw data into columns a model can learn from. A film's genres, for example, become separate yes or no columns like 'drama' and 'comedy'. It's how we turned two datasets into 94 features.
From the Oscar data we kept each film's category, nominees and whether it won. From TMDB we kept its rating, number of votes, revenue, budget, runtime, popularity, genres and production details.
We cleaned film titles so the two datasets would match, filtered to 1927 to 2024, turned genres into yes or no columns through feature engineering, and replaced missing budgets and revenues with the median. We also flagged every category a film was nominated in, and counted its total nominations and total wins. That gave us 94 features.
Three Machine Learning Models to Spot Winners
Learning rateHow big a step the model takes each time it updates its weights. Too small and it converges too slowly, too big and it overshoots the best answer.
We split the data 70/15/15 into training, validation and test sets. The test set held 630 films: 455 non-winners and 175 winners.
Neural network. Our main model, built in PyTorch with two hidden layers. We weighted the rare winners more heavily and trained for 50 epochs with the Adam optimiser. Getting the learning rate right took 3 iterations. At 0 it learned nothing and just guessed 'no win' for 75 percent accuracy, at 0.001 it overshot, and 0.0001 finally worked.
Random forest. 200 decision trees that each ask up to 10 questions about a film, then vote on whether it wins. We weighted winners more heavily so the model wouldn't ignore them.
Logistic regression. A simple baseline with balanced class weights and scaled features.
Initial Results
F1 scoreA score that balances precision, the share of predicted winners that actually won, and recall, the share of actual winners the model caught. 1 means the model is perfect. This is what we used to compare the models.
On the 630 test films, 2/3 models looked almost perfect. The neural network scored an F1 of 0.997, the random forest scored a perfect 1.0, and logistic regression lagged behind with an F1 of ~0.34.
A near-perfect score on a problem as messy as the Oscars made us suspicious, and looking into it, we discovered the models were relying on information they shouldn't have had.
F1, precision, recall and AUC for all three models on the main test set.
Too Good to be True
Data leakageWhen information that wouldn't exist at prediction time sneaks into training. It makes a model look brilliant in testing but useless in the real world. This is what gave us our near-perfect scores.
The random forest can tell you which features it relied on most. One feature dominated: total_wins, with total_nominations a distant second.
The random forest's top 20 features. total_wins carries most of the weight.
That flags an issue because total_wins is a value you wouldn't know before the ceremony, and it overlaps with what we were trying to predict. The model was reading the answer rather than learning what winners look like, a problem called data leakage.
To prove it, we trained on different groups of features: the Oscar context features alone, nominations and wins, gave perfect scores. Commercial signals like budget and revenue reached an F1 of about 0.40, and film details like genre and runtime about 0.29.
F1 and AUC by feature group. The Oscar context group alone scores perfectly.
Many of our near-perfect scores were driven by leaky features.
The 2026 Test
Confusion matrixA 2 by 2 grid of right and wrong answers. The top left and bottom right are correct predictions, the other two are the mistakes.
To test, we built a new test set of 20 films released in 2025, using the Academy's eligibility rule of at least seven consecutive days in U.S. theatres. We put the list together with help from Claude, then ran all three models against the Oscar results from March 15, 2026, where 9/20 films won.
Random forest, 20/20. Perfect again, and for the same leaky reason.
Neural network, 19/20. It caught all nine winners and predicted one win that didn't happen.
Logistic regression, 9/20. It predicted a win for every single film.
Our 2026 results slide. One Battle After Another won Best Picture, and Sinners won Best Actor.Confusion matrices for the 2026 test, neural network, random forest and logistic regression.
We saw the neural network as the most realistic of the three. But it was trained on the same features, so we're cautious about its score too.
Improvements
Remove the leaky features. Rerun every model without total_wins, total_nominations and other nomination information, to see what's really predictive.
Predict each category. Right now a film that wins six Oscars looks the same as one that wins one. Training per category would make the predictions far more useful.
Scale consistently. Our inputs were scaled differently across models. Standardising them means differences come from the models, not the preprocessing.
Add the awards season. Nominations and wins at the Golden Globes, Emmys and other shows that come before the Oscars.
Know the voters. Information about the voting committee and its preferences.
With those changes, we'd expect the neural network to still come out on top.
A Perfect Score is a Question, not an Answer
The most useful thing this project taught me was knowing when to ask clarifying questions, and how to doubt a score that looks too good.
Class imbalance is a real challenge, and leakage can hide inside a feature that looks perfectly reasonable. Checking what a model relies on matters as much as checking how well it scores.