Collaborative Filtering

r̂(u,i) = r̄_u + Σ_{v ∈ N(u)} sim(u,v) · (r_{v,i} - r̄_v)
          ────────────────────────────────────
                Σ_{v ∈ N(u)} |sim(u,v)|

Where:
  r̂(u,i)     = predicted rating for user u, item i
  r̄_u        = mean rating of user u (baseline)
  N(u)       = set of K similar neighbors of u
  sim(u,v)   = similarity between users u and v
  r_{v,i}    = actual rating by neighbor v for item i
  r̄_v        = mean rating of neighbor v

r̂(u,i) = Σ_{j ∈ N(i)} sim(i,j) · r_{u,j}
          ────────────────────────────────
             Σ_{j ∈ N(i)} |sim(i,j)|

Where:
  r̂(u,i)     = predicted rating for user u, item i
  N(i)       = set of items similar to i (that u has rated)
  sim(i,j)   = similarity between items i and j
  r_{u,j}    = actual rating by user u for item j

sim(u, v) = u · v / (||u|| × ||v||)
           = Σ(u_i × v_i) / (√Σu_i² × √Σv_i²)

Geometric interpretation: angle between vectors
Range: [-1, 1] for vectors (typically [0, 1] for ratings)
Ignores magnitude — only direction matters

sim(u, v) = Σ(u_i - ū)(v_i - v̄) / √[Σ(u_i-ū)² × Σ(v_i-v̄)²]

Where ū = mean of user u's ratings, v̄ = mean of user v's ratings

Accounts for rating bias (e.g., one user is more generous)
Subtracts mean before computing similarity
More robust to different rating scales

sim(u, v) = |I_u ∩ I_v| / |I_u ∪ I_v|

Where I_u = set of items rated/clicked by user u

Binary similarity: did they interact or not?
Ignores ratings — only presence/absence
Good for implicit feedback (clicks, purchases)

sim(i, j) = Σ_u (r_{u,i} - r̄_u)(r_{u,j} - r̄_u) / √[Σ(r_{u,i}-r̄_u)² × Σ(r_{u,j}-r̄_u)²]

Cosine similarity after subtracting user mean from each rating
Removes user bias before computing item similarity
Standard choice for collaborative filtering

R ≈ P × Q^T

Where:
  R       = user-item rating matrix (n_users × n_items)
  P       = user latent factor matrix (n_users × k)
  Q       = item latent factor matrix (n_items × k)
  k       = number of latent factors (typically 20-200)

Prediction: r̂_{ui} = p_u · q_i^T (dot product)

Minimize: L = Σ_{(u,i)} (r_{ui} - r̂_{ui})^2 + λ(||P||² + ||Q||²)

Update rules (SGD):
  e_{ui} = r_{ui} - p_u · q_i^T
  p_u ← p_u + α(e_{ui} · q_i - λ · p_u)
  q_i ← q_i + α(e_{ui} · p_u - λ · q_i)

r̂_{ui} = μ + b_u + b_i + p_u · q_i^T

Where:
  μ    = global mean rating
  b_u  = user bias
  b_i  = item bias

import numpy as np

class UserBasedCF:
    def __init__(self, k=5):
        self.k = k
        self.ratings = {}

    def fit(self, ratings_df):
        for _, row in ratings_df.iterrows():
            uid = row['user_id']
            if uid not in self.ratings:
                self.ratings[uid] = {}
            self.ratings[uid][row['item_id']] = row['rating']
        self.user_ids = list(self.ratings.keys())

    def _pearson_sim(self, user1, user2):
        items = (set(self.ratings[user1].keys()) &
                 set(self.ratings[user2].keys()))
        if len(items) < 2:
            return 0
        r1 = np.array([self.ratings[user1][i] for i in items])
        r2 = np.array([self.ratings[user2][i] for i in items])
        m1, m2 = r1.mean(), r2.mean()
        num = ((r1 - m1) * (r2 - m2)).sum()
        denom = np.sqrt(((r1-m1)**2).sum() *
                        ((r2-m2)**2).sum())
        return num / denom if denom > 0 else 0

    def predict(self, user_id, item_id):
        if user_id not in self.ratings:
            return 3.0
        if item_id in self.ratings[user_id]:
            return self.ratings[user_id][item_id]

        sims = []
        for other_user in self.user_ids:
            if other_user == user_id:
                continue
            if item_id in self.ratings[other_user]:
                sim = self._pearson_sim(user_id, other_user)
                sims.append((sim, self.ratings[other_user][item_id]))

        if not sims:
            return 3.0

        sims.sort(key=lambda x: -abs(x[0]))
        neighbors = sims[:self.k]
        total_sim = sum(abs(s) for s, _ in neighbors)
        return sum(s * r for s, r in neighbors) / total_sim

import numpy as np

class ItemBasedCF:
    def __init__(self, k=5):
        self.k = k
        self.ratings = {}
        self.item_sim = {}

    def fit(self, ratings_df):
        for _, row in ratings_df.iterrows():
            uid = row['user_id']
            if uid not in self.ratings:
                self.ratings[uid] = {}
            self.ratings[uid][row['item_id']] = row['rating']

        items = set()
        for user_ratings in self.ratings.values():
            items.update(user_ratings.keys())
        items = list(items)

        for i, item1 in enumerate(items):
            for item2 in items[i+1:]:
                sim = self._item_similarity(item1, item2)
                self.item_sim[(item1, item2)] = sim
                self.item_sim[(item2, item1)] = sim

    def _item_similarity(self, item1, item2):
        users_both = [u for u in self.ratings
                      if item1 in self.ratings[u] and
                      item2 in self.ratings[u]]
        if len(users_both) < 2:
            return 0

        r1 = np.array([self.ratings[u][item1]
                       for u in users_both])
        r2 = np.array([self.ratings[u][item2]
                       for u in users_both])
        means = np.array([np.mean(list(self.ratings[u].values()))
                          for u in users_both])

        r1c = r1 - means
        r2c = r2 - means
        num = (r1c * r2c).sum()
        denom = np.sqrt((r1c**2).sum() * (r2c**2).sum())
        return num / denom if denom > 0 else 0

    def predict(self, user_id, item_id):
        if user_id not in self.ratings:
            return 3.0
        user_items = self.ratings[user_id]
        sims = []
        for user_item in user_items:
            key = (item_id, user_item)
            if key not in self.item_sim:
                key = (user_item, item_id)
            if key in self.item_sim:
                sim = self.item_sim[key]
                if sim > 0:
                    sims.append((sim, user_items[user_item]))

        if not sims:
            return 3.0

        sims.sort(key=lambda x: -x[0])
        neighbors = sims[:self.k]
        total_sim = sum(s for s, _ in neighbors)
        return sum(s * r for s, r in neighbors) / total_sim

import numpy as np

class MatrixFactorization:
    def __init__(self, factors=50, lr=0.01, lam=0.01, epochs=100):
        self.factors = factors
        self.lr = lr
        self.lam = lam
        self.epochs = epochs

    def fit(self, ratings_df):
        users = ratings_df['user_id'].unique()
        items = ratings_df['item_id'].unique()
        self.user_map = {u: i for i, u in enumerate(users)}
        self.item_map = {i: j for j, i in enumerate(items)}

        n_u, n_i = len(users), len(items)
        self.P = np.random.normal(0, 0.1, (n_u, self.factors))
        self.Q = np.random.normal(0, 0.1, (n_i, self.factors))
        self.bu = np.zeros(n_u)
        self.bi = np.zeros(n_i)
        self.mean = ratings_df['rating'].mean()

        for _ in range(self.epochs):
            for _, row in ratings_df.iterrows():
                u = self.user_map[row['user_id']]
                i = self.item_map[row['item_id']]
                r = row['rating']
                r_hat = (self.mean + self.bu[u] + self.bi[i] +
                         np.dot(self.P[u], self.Q[i]))
                e = r - r_hat
                self.bu[u] += self.lr * (e - self.lam * self.bu[u])
                self.bi[i] += self.lr * (e - self.lam * self.bi[i])
                self.P[u] += self.lr * (e * self.Q[i] - self.lam * self.P[u])
                self.Q[i] += self.lr * (e * self.P[u] - self.lam * self.Q[i])

    def predict(self, user_id, item_id):
        if user_id not in self.user_map or item_id not in self.item_map:
            return self.mean
        u = self.user_map[user_id]
        i = self.item_map[item_id]
        return (self.mean + self.bu[u] + self.bi[i] +
                np.dot(self.P[u], self.Q[i]))

import pandas as pd

# Create sample data
data = {
    'user_id': [0, 0, 0, 1, 1, 1, 2, 2, 2],
    'item_id': [0, 1, 2, 1, 2, 3, 0, 2, 3],
    'rating': [5, 4, 3, 5, 4, 2, 4, 5, 3]
}
df = pd.DataFrame(data)

# Test User-Based CF
cf = UserBasedCF(k=2)
cf.fit(df)
pred = cf.predict(user_id=0, item_id=3)
print(f"User-Based prediction: {pred:.2f}")

# Test Item-Based CF
icf = ItemBasedCF(k=2)
icf.fit(df)
pred = icf.predict(user_id=0, item_id=3)
print(f"Item-Based prediction: {pred:.2f}")

# Test Matrix Factorization
mf = MatrixFactorization(factors=5, epochs=20)
mf.fit(df)
pred = mf.predict(user_id=0, item_id=3)
print(f"Matrix Factorization prediction: {pred:.2f}")