Why Recommendations Matter

Personalized recommendations drive engagement and revenue. Amazon attributes 35% of purchases to its recommendation engine. Netflix estimates recommendations save $1B annually in retention.

Recommendation Approaches

Collaborative Filtering

Recommend items based on similar users' preferences:

import numpy as np
from scipy.sparse import csr_matrix
from sklearn.neighbors import NearestNeighbors

# User-item matrix
ratings_matrix = csr_matrix(ratings_df.pivot(
    index='user_id', 
    columns='item_id', 
    values='rating'
).fillna(0))

# Find similar users
model = NearestNeighbors(metric='cosine', algorithm='brute')
model.fit(ratings_matrix)

def get_recommendations(user_id, n=10):
    user_vector = ratings_matrix[user_id]
    distances, indices = model.kneighbors(user_vector, n_neighbors=20)
    
    # Aggregate ratings from similar users
    similar_users_ratings = ratings_matrix[indices.flatten()].mean(axis=0)
    
    # Filter already rated items
    user_rated = set(ratings_df[ratings_df.user_id == user_id].item_id)
    recommendations = [
        (i, score) for i, score in enumerate(similar_users_ratings.A1)
        if i not in user_rated
    ]
    
    return sorted(recommendations, key=lambda x: -x[1])[:n]

Content-Based Filtering

Recommend items similar to what user liked before:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Create item profiles from descriptions
vectorizer = TfidfVectorizer(stop_words='english')
item_profiles = vectorizer.fit_transform(items_df['description'])

def content_recommendations(liked_item_ids, n=10):
    # Create user profile from liked items
    user_profile = item_profiles[liked_item_ids].mean(axis=0)
    
    # Find similar items
    similarities = cosine_similarity(user_profile, item_profiles).flatten()
    
    # Exclude already liked items
    recommendations = [
        (i, sim) for i, sim in enumerate(similarities)
        if i not in liked_item_ids
    ]
    
    return sorted(recommendations, key=lambda x: -x[1])[:n]

Hybrid Approach

def hybrid_recommendations(user_id, liked_items, n=10):
    # Get both types of recommendations
    collab_recs = get_recommendations(user_id, n=n*2)
    content_recs = content_recommendations(liked_items, n=n*2)
    
    # Combine with weights
    scores = {}
    for item_id, score in collab_recs:
        scores[item_id] = scores.get(item_id, 0) + 0.6 * score
    for item_id, score in content_recs:
        scores[item_id] = scores.get(item_id, 0) + 0.4 * score
    
    return sorted(scores.items(), key=lambda x: -x[1])[:n]

Deep Learning Approaches

Neural Collaborative Filtering

import torch
import torch.nn as nn

class NCF(nn.Module):
    def __init__(self, num_users, num_items, embedding_dim=64):
        super().__init__()
        self.user_embedding = nn.Embedding(num_users, embedding_dim)
        self.item_embedding = nn.Embedding(num_items, embedding_dim)
        self.fc_layers = nn.Sequential(
            nn.Linear(embedding_dim * 2, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 1)
        )
        
    def forward(self, user_ids, item_ids):
        user_embed = self.user_embedding(user_ids)
        item_embed = self.item_embedding(item_ids)
        concat = torch.cat([user_embed, item_embed], dim=-1)
        return self.fc_layers(concat).squeeze()

Production Considerations

Cold Start Problem

• New users: Use content-based or popularity
• New items: Use content similarity
• Collect implicit feedback quickly

Real-Time vs Batch

• Batch: Pre-compute recommendations daily
• Real-time: Update based on session activity
• Hybrid: Batch base + real-time adjustment

Evaluation Metrics

• Precision@K: Relevant items in top K
• Recall@K: Coverage of relevant items
• NDCG: Ranking quality
• A/B Testing: Business metrics (CTR, conversion)

Conclusion

Start simple with collaborative filtering, add content-based for cold start, and evolve to deep learning as your data grows. Always validate with A/B tests.