Building AI Recommendation Systems

Types of Recommendation Systems

1. Collaborative Filtering

Finds patterns based on user behavior:

"Users like you also liked..."

Doesn't need item features

2. Content-Based Filtering

Recommends based on item features:

"Because you liked action movies..."

Needs rich item metadata

3. Hybrid Systems

Combines both approaches for best results.

Matrix Factorization

python
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.linalg import svds
User-item interaction matrix
R = csr_matrix(user_item_interactions)
SVD decomposition
U, sigma, Vt = svds(R, k=50)  # k = number of latent factors
Reconstruct predicted ratings
sigma_diag = np.diag(sigma)
predicted_ratings = U.dot(sigma_diag).dot(Vt)
def get_recommendations(user_id, n=10):
    user_ratings = predicted_ratings[user_id]
    # Exclude already-interacted items
    interacted = R[user_id].nonzero()[1]
    user_ratings[interacted] = -np.inf
    return np.argsort(user_ratings)[::-1][:n]

Neural Collaborative Filtering

python
import torch
import torch.nn as nn
class NCF(nn.Module):
    def __init__(self, n_users, n_items, embedding_dim=64):
        super().__init__()
        self.user_embedding = nn.Embedding(n_users, embedding_dim)
        self.item_embedding = nn.Embedding(n_items, embedding_dim)
        
        self.mlp = nn.Sequential(
            nn.Linear(embedding_dim * 2, 128),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 1),
            nn.Sigmoid()
        )
    
    def forward(self, user_ids, item_ids):
        user_emb = self.user_embedding(user_ids)
        item_emb = self.item_embedding(item_ids)
        combined = torch.cat([user_emb, item_emb], dim=1)
        return self.mlp(combined).squeeze()

Two-Tower Architecture (Production Scale)

python
class TwoTowerModel(nn.Module):
    def __init__(self):
        super().__init__()
        # User tower
        self.user_tower = nn.Sequential(
            nn.Linear(user_features_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 128)
        )
        # Item tower  
        self.item_tower = nn.Sequential(
            nn.Linear(item_features_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 128)
        )
    
    def forward(self, user_features, item_features):
        user_emb = self.user_tower(user_features)
        item_emb = self.item_tower(item_features)
        return torch.cosine_similarity(user_emb, item_emb)

Retrieval + Ranking Pipeline

Retrieval: Use ANN (approximate nearest neighbor) to get top 1000 candidates

Ranking: Score candidates with a more complex model

Post-processing: Business rules, diversity, freshness boost