Build Beyond: Which Algorithm Actually Works Best for Movie Recommendations?

The recommendation system rabbit hole goes deeper than you think. Here’s what I discovered when I built my own algorithm comparison framework.

The world of recommendation systems always fascinated me, but I never truly understood the complexity until I decided to build one myself. What started as an MIT course project implementing Expectation-Maximization for collaborative filtering turned into something much bigger — a comprehensive comparison of multiple ML algorithms on realistic Netflix-density data.

This is the story of that journey, the numbers I got, and what I learned along the way. This is also the first in a series where I take existing projects and expand their scope with different frameworks and approaches to see what happens when you push beyond the original boundaries.

The Challenge: Comparing Algorithms on Real-World Data Density

When most people think of recommendation systems, they imagine the simple “users who bought this also bought that” approach. But I wanted to understand how different algorithms actually perform when faced with realistic data sparsity.

My dataset had the characteristics of real recommendation problems:

• 1,440,000 total possible ratings (1200 users × 1200 movies)
• 1,111,768 observed ratings
• 22.79% sparsity — much denser than extreme cases but still challenging

The question became: which algorithm handles missing data patterns most effectively, and what are the practical trade-offs between different approaches?

I decided to test this with five different algorithms:

• Mean Imputation (the baseline)
• EM Clustering
• KNN User-based Collaborative Filtering
• KNN Item-based Collaborative Filtering
• Matrix Factorization (both NMF and SVD variants)

Each algorithm represents a different philosophy for handling collaborative filtering, and I wanted to see how they actually performed when the rubber met the road.

The Algorithms: Different Approaches to the Same Problem

Mean Imputation: The Honest Baseline Sometimes the simplest approach is the most honest one. Mean imputation just fills missing ratings with the global average. It’s not sophisticated, but it gives you a reality check on whether your fancy algorithms are actually doing anything useful.

EM Clustering: Finding Hidden User Groups The Expectation-Maximization(EM) algorithm assumes users can be grouped into clusters with similar preferences. It iteratively assigns users to clusters and updates cluster parameters until convergence. The beauty of EM is that it doesn’t just fill in missing values — it discovers latent user segments.

KNN: The Power of Similarity K-Nearest Neighbors comes in two flavors: user-based and item-based. User-based finds similar users and uses their ratings to predict yours. Item-based finds similar movies and uses ratings patterns across those movies.

Matrix Factorization: The Dimensionality Reduction Approach Matrix factorization decomposes the user-movie matrix into lower-dimensional matrices, essentially learning latent features that capture user preferences and movie characteristics. I tested both Non-negative Matrix Factorization (NMF) and Singular Value Decomposition (SVD).

The Results: A More Nuanced Story

After running all algorithms on the same dataset, the numbers revealed a fascinating story about trade-offs:

[embed]

While Item-based KNN emerged as the winner in raw accuracy, the most interesting story came from the Matrix Factorization models. Initially, NMF performed poorly, but after addressing a convergence warning by increasing its iterations, it became a highly competitive model. This highlights that in practice, simple neighbor-based approaches can be very powerful, but a well-tuned factorization model is right there with them.

What I Learned: Beyond the Numbers

Performance vs. Interpretability Trade-offs While KNN won on accuracy, EM clustering provided the most interpretable results. I could actually understand which users were grouped together and why. This matters a lot in production systems where you need to explain recommendations.

The Speed-Accuracy Balance SVD’s 0.81-second training time versus NMF’s 16.60 seconds was eye-opening. SVD delivered a 20x speedup while achieving very competitive accuracy. For systems needing rapid retraining, this makes SVD an incredibly pragmatic choice.

Algorithm Comparison Methodology Matters This was powerfully demonstrated by the NMF model. It initially underperformed due to a ConvergenceWarning. By simply increasing the allowed iterations, its RMSE improved from 0.882 to 0.499. This proved that rigorous tuning and paying attention to model warnings are essential for a fair comparison.

Implementation Reality vs. Theory Working with these algorithms in practice gave me a deep appreciation for the engineering considerations that go into production-ready implementations. Convergence criteria, numerical stability, and edge case handling matter enormously.

Making the Analysis Transparent: The Power of a Notebook

Numbers on a screen are one thing, but telling a clear, reproducible story is another. By consolidating the entire analysis into a single Jupyter Notebook, the project becomes more than just a set of results — it becomes a transparent narrative.

The notebook format allows anyone to:

• Follow the logical flow from data loading to final conclusions.
• See the code, visualizations, and commentary side-by-side.
• Re-run the entire experiment to verify the findings for themselves.

This approach focuses on reproducibility and clarity, ensuring that the insights are not just presented, but are also backed by accessible and verifiable code.

What’s Next: The Series Continues

This project convinced me there’s value in taking existing projects and expanding their scope with different technical approaches. The recommendation system space is evolving rapidly with deep learning, and future explorations could include:

• Neural collaborative filtering implementations
• Transformer-based recommendation models
• Hybrid content + collaborative approaches

Whether you’re building the next Netflix or just trying to understand how recommendations work, starting with these core algorithms and implementing systematic comparisons provides insights that no amount of reading can match.

Try It Yourself

The complete code and reproducible analysis are available in the main Jupyter Notebook on my **GitHub**. If you’re interested in recommendation systems or want to discuss the trade-offs between different approaches, feel free to connect.

This is the first in a series of “Build Beyond” projects where I expand existing work with different frameworks and approaches. The goal is always the same: push beyond the original scope and see what we can learn from systematic comparison and contrast.