Collaborative Filtering Recommendation Engine

Movie Recommendation System: A Practical Guide

Date: June 2, 2025

Author: Muhammad Ahsan

1. What This Is All About (Introduction)

Ever wondered how websites seem to know just what movies you might like? That’s the magic of recommendation systems! This report dives into a project where we built a basic version of one. Our goal was to get a feel for how these systems work and create something that could suggest movies to people based on what they’ve watched and liked before. These kinds of systems are everywhere these days, and they’re a big part of what makes online streaming and shopping feel so personal.

For our project, we decided to go with a popular method called Item-Item Collaborative Filtering.

2. Our Game Plan: Item-Item Collaborative Filtering

So, what exactly is Item-Item Collaborative Filtering? Imagine you loved a particular movie. This method works by finding other movies that are "similar" to the one you loved, not based on their genre or actors, but based on how other people have rated them. If lots of people who liked Movie A also liked Movie B, then the system figures Movie A and Movie B are probably similar in some way that appeals to the same tastes.

Here’s the basic idea in a few steps:

See What Everyone’s Watching: First, we look at all the ratings. We usually organize this into a big grid where we have users, movies, and the ratings each user gave to each movie.

Figure Out Which Movies are Alike: Next, the system compares every movie to every other movie. It looks for pairs of movies that tend to get similar ratings from the same users. If Movie X and Movie Y consistently get high ratings (or low ratings) from the same bunch of people, they're considered similar. We used a math trick called "cosine similarity" to measure this.

Suggest New Flicks: Now, to recommend something to you, the system looks at the movies you’ve already rated highly. It then finds other movies that are very similar to your favorites (but that you haven’t seen yet) and suggests those. The "predicted rating" it shows you is basically a smart guess based on how much you liked similar movies.

Why we picked this method:

It’s a tried-and-true approach that often works really well, especially if you have a decent amount of rating data.

It can sometimes surprise you with recommendations for movies you might not have thought to look for, but that people with similar tastes to yours have enjoyed.

We didn’t need a ton of extra details about each movie (like who directed it or a full plot summary). We just needed the ratings, which made it simpler to get started for this project.

Movie tastes (what makes movies similar) tend to change less often than individual users' preferences, so the "similarity scores" between movies can be quite stable.

3. How We Built It (Implementation Details)

Here’s a peek under the hood at how we put our recommendation system together:

3.1. Getting the Data Ready

We started with our movie_ratings.csv file, which had the basics: user_id, movie_id, and the rating (from 1 to 5). In our run, this file had 5000 ratings from 200 users for 100 different movies.

A Bit of Tidying Up (Filtering): Sometimes, you have users who’ve only rated one or two movies, or movies that only a couple of people have seen. This can make it hard to get reliable recommendations. So, we set a rule: users needed to have rated at least 5 movies, and movies needed at least 3 ratings to be included. In the specific run that produced our example results, it turned out all our users and movies already met this, so no data was actually filtered out at this stage. We still had 200 users, 100 movies, and 5000 ratings to work with.

3.2. Making the User-Movie Grid

We then organized our ratings into a big grid (or matrix, if you like fancy terms). Think of it like a spreadsheet where each row is a user, each column is a movie, and the cells contain the rating that user gave that movie.

If a user hadn’t rated a particular movie, we just put a 0 in that cell. This helps with the math later on. Our grid ended up being 200 users by 100 movies.

3.3. Finding Similar Movies

To compare movies, we flipped our grid around so that movies were the rows and users were the columns.

Cosine Similarity to the Rescue: We used a common technique called "cosine similarity" to see how alike movies were. It’s a way of measuring how similar the pattern of ratings is for any two movies. A score close to 1 means they're very similar in terms of who liked them, while a score closer to 0 means they're not very similar. For example, in our results, Movie ID 1 was most similar to Movie ID 64 (score of about 0.42) and Movie ID 2 (score of about 0.34).

3.4. Cooking Up Recommendations

We wrote a function called get_movie_recommendations_for_user that does the actual recommending:

You tell it which user_id you want recommendations for.

It looks up all the movies that user has already rated.

Then, for each movie the user liked, it finds other movies that are very similar (using our similarity scores).

It cleverly combines these: if you loved Movie X, and Movie Y is very similar to Movie X, then Movie Y gets a good "recommendation score." It does this for all the movies you've rated.

Finally, it calculates a "predicted rating" for movies you haven't seen, based on how much you liked similar ones.

It then sorts these potential recommendations by the highest predicted rating and shows you the top few (we set it to 10). For instance, for User ID 1, the top recommended movie was Movie ID 5, with a predicted rating of about 3.63.

4. How to Use Our Recommender

Want to get some movie suggestions? Here’s how:

Make Sure the Data’s There: You’ll need the movie_ratings.csv file in the same place as the Python script. If you don’t have it, run the script that generates this mock data first.

Run the Main Script: Execute the Python script that has all the recommendation logic.

Ask for Recommendations: The script has an example of how to use the get_movie_recommendations_for_user function. You’ll just need to change the user_id to whoever you want suggestions for.

# This is how it looks in the script:

# sample_user_id = 1 # Or any user_id you're interested in

# recommendations = get_movie_recommendations_for_user(sample_user_id, user_item_matrix, item_similarity_df)

# print(recommendations)

Check Out the Suggestions: The function will give you a list of movie IDs and their predicted ratings, showing you what it thinks you might like.

So, if you wanted to get 10 recommendations for user_id = 42 (assuming that user is in your data), you’d make a call like this: recs = get_movie_recommendations_for_user(42, user_item_matrix, item_similarity_df, top_n=10)

5. Things to Keep in Mind (Limitations and Future Ideas)

Our system is a great start, but like any basic model, it has a few quirks and areas where it could be even better:

The "New Kid" Problem (Cold Start): If a new user signs up and hasn't rated anything, our system won't know what to suggest. Same for brand new movies that nobody has rated yet – it's hard to tell how similar they are to anything else. Other methods, like looking at movie genres (content-based filtering), could help here.

Not Many Ratings (Data Sparsity): If most users have only rated a tiny fraction of the movies, it can be tough to find strong similarities. We tried to help this by filtering, but it’s a common challenge.

Big Data, Big Calculations: For a huge number of movies and users, calculating all those similarities can take a lot of computer power and memory. There are more advanced techniques for handling this if we were dealing with millions of ratings.

How Good Is It, Really? (Evaluation): We didn't build in a formal way to test how good our recommendations are (like using metrics such as precision@k or recall@k). That would be a really important next step to properly measure its performance.

Everyone Likes That (Popularity Bias): Sometimes, these systems can end up recommending popular movies a bit too often. There are ways to try and make the suggestions more diverse or surprising.

Keeping it Fresh: This system works on the data it has right now. In the real world, you’d want it to update as new ratings come in.

6. So, What's the Verdict? (Conclusion)

We successfully built a working Item-Item Collaborative Filtering movie recommender! It showed us the main steps involved: getting data ready, figuring out how similar movies are, and then using that to make suggestions. Even though it’s a basic version, it gives a good understanding of how these smart systems can learn from user behavior to offer personalized recommendations. It also gives us a clear path for how we could make it even more powerful and test it more rigorously in the future.