/recommendation-engine

name: Recommendation Engine
description: Build recommendation systems using collaborative filtering, content-based filtering, matrix factorization, and neural network approaches

Recommendation Engine

Overview

This skill provides comprehensive implementation of recommendation systems using collaborative filtering, content-based filtering, matrix factorization, and hybrid approaches to predict user preferences and deliver personalized suggestions.

When to Use

• Building personalized product recommendations for e-commerce platforms
• Creating content recommendation systems for streaming services, news platforms, or social media
• Implementing user-user or item-item collaborative filtering based on interaction patterns
• Addressing cold start problems for new users or items with limited interaction history
• Evaluating recommendation quality using precision@k, recall@k, and NDCG metrics
• Scaling recommendation systems to handle millions of users and items efficiently

Recommendation Approaches

• **Collaborative Filtering**: Using user-item interaction patterns
• **Content-Based**: Recommending similar items based on features
• **Hybrid**: Combining multiple approaches
• **Matrix Factorization**: Decomposing user-item matrix
• **Neural Networks**: Deep learning for embeddings
• **Knowledge-Based**: Using domain knowledge and rules

Key Techniques

• **User-User Similarity**: Finding similar users
• **Item-Item Similarity**: Finding similar items
• **Latent Factors**: Hidden patterns in data
• **Embeddings**: Vector representations of users/items
• **Graph-Based**: Social networks and item graphs

Python Implementation

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances
from sklearn.decomposition import TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer
from scipy.sparse import csr_matrix
import warnings
warnings.filterwarnings('ignore')

print("=== 1. Collaborative Filtering ===")

# Create sample user-item interaction matrix
np.random.seed(42)
n_users = 50
n_items = 30

# Create sparse interaction matrix (ratings: 0-5)
interaction_matrix = np.random.randint(0, 6, size=(n_users, n_items))
# Make it sparse (many zeros)
interaction_matrix[np.random.random((n_users, n_items)) > 0.3] = 0

print(f"User-Item Matrix Shape: {interaction_matrix.shape}")
print(f"Sparsity: {(interaction_matrix == 0).sum() / interaction_matrix.size:.2%}")

# User-based collaborative filtering
print("\n=== User-Based Collaborative Filtering ===")

# Normalize ratings
user_means = np.nanmean(np.where(interaction_matrix != 0, interaction_matrix, np.nan), axis=1, keepdims=True)
user_means[np.isnan(user_means)] = 0

interaction_normalized = interaction_matrix - user_means

# Convert to sparse matrix
interaction_sparse = csr_matrix(interaction_normalized)

# Compute user-user similarity
user_similarity = cosine_similarity(interaction_sparse)

print(f"User Similarity Matrix Shape: {user_similarity.shape}")
print(f"Sample user similarity [0,1]: {user_similarity[0, 1]:.4f}")

# 2. Item-based collaborative filtering
print("\n=== Item-Based Collaborative Filtering ===")

# Compute item-item similarity
item_similarity = cosine_similarity(interaction_sparse.T)

print(f"Item Similarity Matrix Shape: {item_similarity.shape}")
print(f"Sample item similarity [0,1]: {item_similarity[0, 1]:.4f}")

# 3. Matrix Factorization (SVD)
print("\n=== Matrix Factorization (SVD) ===")

# Apply SVD
svd = TruncatedSVD(n_components=5, random_state=42)
user_factors = svd.fit_transform(interaction_sparse)
item_factors = svd.components_.T

print(f"User Factors Shape: {user_factors.shape}")
print(f"Item Factors Shape: {item_factors.shape}")
print(f"Explained Variance Ratio: {svd.explained_variance_ratio_.sum():.4f}")

# Reconstruct ratings
reconstructed_ratings = user_factors @ item_factors.T + user_means

print(f"Reconstructed Ratings Shape: {reconstructed_ratings.shape}")
print(f"Reconstruction Error: {np.mean((interaction_matrix - reconstructed_ratings) ** 2):.4f}")

# 4. Content-Based Filtering
print("\n=== Content-Based Filtering ===")

# Create item features (e.g., product descriptions)
item_descriptions = [
    "action adventure movie thriller",
    "romantic comedy drama love",
    "sci-fi technology future space",
    "horror scary thriller dark",
    "animation family kids fun",
    "adventure action explosions",
    "documentary educational learning",
    "sports competition championship",
    "musical dance entertainment",
    "historical drama biography"
]

# Expand to 30 items
item_descriptions = (item_descriptions * 4)[:30]

# Create TF-IDF vectors
tfidf = TfidfVectorizer(lowercase=True)
item_features = tfidf.fit_transform(item_descriptions)

# Compute item-item similarity based on content
content_similarity = cosine_similarity(item_features)

print(f"Item Feature Matrix Shape: {item_features.shape}")
print(f"Content-based Item Similarity [0,1]: {content_similarity[0, 1]:.4f}")

# 5. Hybrid Recommendation System
print("\n=== Hybrid Recommendation System ===")

class HybridRecommender:
    def __init__(self, user_similarity, item_similarity, interaction_matrix):
        self.user_similarity = user_similarity
        self.item_similarity = item_similarity
        self.interaction_matrix = interaction_matrix
        self.n_users = interaction_matrix.shape[0]
        self.n_items = interaction_matrix.shape[1]

    def recommend_user_based(self, user_id, n_recommendations=5):
        """User-based collaborative filtering recommendation"""
        # Get similar users
        similar_users = self.user_similarity[user_id]
        similar_indices = np.argsort(similar_users)[-5:-1]  # Top 4 similar users

        # Get items rated highly by similar users
        similar_users_ratings = self.interaction_matrix[similar_indices]
        user_items = self.interaction_matrix[user_id]

        # Items