Recommendation systems power many of the applications we use daily, from Netflix movie suggestions to Amazon product recommendations. These systems analyze user preferences and suggest relevant content.

In this guide, we’ll build a simple recommendation system in Python using collaborative filtering and content-based filtering.

What is a Recommendation System?

A recommendation system predicts user preferences and suggests relevant products, movies, or articles based on their behavior or interests.

Types of Recommendation Systems

• Content-Based Filtering: Recommends items similar to those a user has interacted with.
• Collaborative Filtering: Recommends items based on similar user preferences.
• Hybrid Models: Combines both approaches for better accuracy.

Setting Up the Environment

First, install the necessary libraries:

pip install pandas numpy scikit-learn

Method 1: Content-Based Filtering

Content-based filtering recommends items based on similarity between features.

Step 1: Load the Dataset

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Sample dataset
data = pd.DataFrame({
    'Movie': ['Inception', 'Interstellar', 'The Dark Knight', 'Tenet'],
    'Genre': ['Sci-Fi Action', 'Sci-Fi Drama', 'Action Crime', 'Sci-Fi Thriller']
})

Step 2: Convert Text to Numerical Data

# Convert genre text into numerical representation
vectorizer = TfidfVectorizer()
genre_matrix = vectorizer.fit_transform(data['Genre'])

# Compute similarity scores
similarity = cosine_similarity(genre_matrix)

Step 3: Recommend Similar Movies

def recommend_movie(movie_name):
    idx = data[data['Movie'] == movie_name].index[0]
    scores = list(enumerate(similarity[idx]))
    scores = sorted(scores, key=lambda x: x[1], reverse=True)[1:3]  # Top 2 recommendations
    return [data.iloc[i[0]]['Movie'] for i in scores]

print(recommend_movie('Inception'))

Method 2: Collaborative Filtering

Collaborative filtering recommends items based on user preferences and behavior.

Step 1: Create a User-Item Matrix

# Sample ratings data
ratings = pd.DataFrame({
    'User': [1, 1, 2, 2, 3, 3],
    'Movie': ['Inception', 'Interstellar', 'Inception', 'The Dark Knight', 'Interstellar', 'Tenet'],
    'Rating': [5, 4, 4, 5, 5, 3]
})

# Create a user-movie matrix
user_movie_matrix = ratings.pivot_table(index='User', columns='Movie', values='Rating')

Step 2: Compute Similarities Between Users

from sklearn.metrics.pairwise import cosine_similarity

# Fill NaN values with 0
user_movie_matrix = user_movie_matrix.fillna(0)

# Compute user similarity
user_similarity = cosine_similarity(user_movie_matrix)

# Convert to DataFrame
user_similarity_df = pd.DataFrame(user_similarity, index=user_movie_matrix.index, columns=user_movie_matrix.index)

Step 3: Recommend Movies Based on Similar Users

def recommend_for_user(user_id):
    similar_users = user_similarity_df[user_id].sort_values(ascending=False)[1:3].index
    recommended_movies = ratings[ratings['User'].isin(similar_users)]['Movie'].unique()
    return recommended_movies

print(recommend_for_user(1))

Comparison of Methods

Best Practices for Building Recommendation Systems

• Use Hybrid Models: Combining content-based and collaborative filtering improves accuracy.
• Regularly Update Data: Ensure recommendations remain relevant.
• Evaluate Model Performance: Use precision, recall, and RMSE metrics.

FAQs

• Which recommendation system is better? It depends on the dataset. Collaborative filtering works well for large datasets, while content-based filtering is better for small datasets.
• Can I use deep learning for recommendations? Yes, deep learning techniques like autoencoders and neural collaborative filtering can enhance accuracy.
• How do I deploy a recommendation system? Use Flask or FastAPI to create an API and serve recommendations.
• What dataset size is needed for collaborative filtering? It works best with large datasets to find meaningful user similarities.
• Can I use recommendation systems for other applications? Yes, they are used in music, e-commerce, healthcare, and more.

Conclusion

Building a recommendation system in Python is a great way to learn about machine learning and AI. By using content-based or collaborative filtering, you can create personalized suggestions for users.

Start experimenting with recommendation systems today and enhance user experiences!