Recommender system — collaborative filtering আর matrix factorization

AI-এর ভিত্তি কোর্সের পর্ব ৩৩-এ cosine similarity, পর্ব ৫৬-এ সময় মেনে ডেটা ভাগ, আর পর্ব ৬০-এ precision ও recall দেখেছেন। এই কোর্সের পর্ব ০৯ দেখিয়েছে, রেটিং matrix-এর low-rank রূপ কীভাবে “রুচির অক্ষ” বের করে, আর সেখানেই প্রশ্ন রেখে এসেছিল: বেশিরভাগ ঘর খালি হলে কী হবে? এই পর্ব সেই প্রশ্নের উত্তর, শুরু থেকে মূল্যায়ন পর্যন্ত। চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy, pandas আর matplotlib); প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে।

১ · ক্রেতা × পণ্যের matrix — explicit, implicit আর ফাঁকা ঘর

ডেটার রূপ একটি matrix R: সারি ক্রেতা (u), কলাম পণ্য (i), ঘরে r_ui. ঘরের মান দুই ধরনের হতে পারে। Explicit feedback মানে ক্রেতা নিজে মত দিয়েছেন, যেমন ১ থেকে ৫ তারা। Implicit feedback মানে আচরণ থেকে আন্দাজ: কিনেছেন, কার্টে রেখেছেন, পাতা খুলেছেন, কতক্ষণ দেখেছেন। Implicit ডেটা অনেক বেশি পরিমাণে আসে, কিন্তু তাতে “অপছন্দ” লেখা থাকে না: না-কেনার কারণ অপছন্দ হতে পারে, আবার পণ্যটি চোখে না পড়াও হতে পারে।

দ্বিতীয় বৈশিষ্ট্য sparsity: একজন ক্রেতা ক্যাটালগের সামান্য অংশ ছোঁন, তাই বেশিরভাগ ঘর খালি। তৃতীয় বৈশিষ্ট্য long tail: অল্প কয়েকটি পণ্য প্রায় সবাই কেনেন, আর বাকি অসংখ্য পণ্য অল্প কয়েকজন। তিনটি মিলে বিপদ তৈরি করে। খালি ঘরকে ০ ধরলে মডেল শেখে “না দেখা = সবচেয়ে খারাপ”। আর জনপ্রিয় পণ্যের তথ্য বেশি বলে মডেল সহজেই শুধু জনপ্রিয় পণ্যই সুপারিশ করতে শেখে।

এই পর্বের ডেটা কাল্পনিক, seed দিয়ে বানানো। বাজারঘরের ৩০০ ক্রেতা, ১২০টি পণ্য, চারটি বিভাগ (grocery, gadget, beauty, book). প্রত্যেক ক্রেতার ভেতরে চার বিভাগের প্রতি একটি গোপন রুচি আছে, প্রতিটি পণ্যের একটি জনপ্রিয়তা আর মান আছে, আর কিছু ক্রেতা স্বভাবে উদার (বেশি তারা দেন)। ক্রেতারা রুচি আর জনপ্রিয়তা অনুযায়ী কেনেন, ১৮০ দিনের মধ্যে কোনো এক দিনে, তারপর রেটিং দেন। Algorithm শুধু (user, item, rating, day) দেখে, গোপন রুচি দেখে না। split_last প্রত্যেক ক্রেতার সময়ে শেষ কেনাটি আলাদা করে রাখে, যা দিয়ে অংশ ৬-এ মূল্যায়ন হবে।

# bazar_rec.py — বাজারঘরের কাল্পনিক ক্রেতা × পণ্য রেটিং, সময়সহ (seed দিয়ে বানানো)
import numpy as np
import pandas as pd

CATS = np.array(["grocery", "gadget", "beauty", "book"])

def make_ratings(n_users=300, n_items=120, seed=53):
    rng = np.random.default_rng(seed)
    cat = np.arange(n_items) % 4                        # প্রতিটি পণ্যের বিভাগ
    V = 1.6 * np.eye(4)[cat] + rng.normal(0, 0.3, (n_items, 4))
    U = 3 * rng.dirichlet(np.full(4, 0.3), n_users)     # ক্রেতার গোপন রুচি
    pop = rng.gumbel(0, 0.9, n_items)                   # কিছু পণ্য সবার চেনা
    qual = rng.normal(0, 0.5, n_items)                  # পণ্যের মান
    gen = rng.normal(0, 0.4, n_users)                   # কেউ উদার, কেউ কড়া
    rows = []
    for u in range(n_users):
        w = np.exp(U[u] @ V.T + pop); w /= w.sum()
        n = 4 + rng.poisson(8)
        items = rng.choice(n_items, n, replace=False, p=w)
        days = np.sort(rng.choice(180, n, replace=False))
        s = 1.4 + 0.8 * U[u] @ V[items].T + qual[items] + gen[u]
        r = np.clip(np.round(s + rng.normal(0, 0.5, n)), 1, 5)
        rows += [(u, i, int(x), int(d)) for i, x, d in zip(items, r, days)]
    df = pd.DataFrame(rows, columns=["user", "item", "rating", "day"])
    return df, cat

def split_last(df):
    """প্রত্যেক ক্রেতার সময়ে শেষ কেনাটি test-এ, বাকি সব train-এ।"""
    last = df.groupby("user")["day"].transform("max") == df["day"]
    return df[~last].reset_index(drop=True), df[last].reset_index(drop=True)

২ · Popularity baseline আর neighbourhood পদ্ধতি — cosine দিয়ে item-based CF

প্রথম মাপকাঠি সবচেয়ে সরল: সবাইকে সবচেয়ে বেশি বিক্রি হওয়া পণ্য দেখানো (যা ক্রেতা আগে কেনেননি)। এটি ব্যক্তিগত নয়, তবু অবাক করার মতো শক্ত, কারণ জনপ্রিয় পণ্য অনেকেই কিনবেন। পর্ব ০২-এর নিয়ম মনে রাখুন: যে মডেল এই baseline-কে হারাতে পারে না, তা জটিলতার যোগ্য নয়।

Collaborative filtering (CF) বলে: পণ্যের বিবরণ না জেনেও, অনেক ক্রেতার আচরণের মিল থেকে একজনের পছন্দ আন্দাজ করা যায়। দুটি রূপ। User-based CF: আপনার মতো রুচির ক্রেতা খুঁজে তাঁরা যা পছন্দ করেছেন তা দেখানো। Item-based CF: আপনি যে পণ্যগুলো পছন্দ করেছেন, সেগুলোর মতো পণ্য দেখানো। দুই পণ্য “মতো” যদি একই ক্রেতারা দুটিকে একইভাবে রেট করেন। মিলের মাপ সাধারণত cosine similarity: পণ্য i আর j-এর কলাম-vector (প্রতিটি ক্রেতার রেটিং, খালি হলে ০) ধরে

sim(i, j) = (r_i · r_j) / (‖r_i‖ ‖r_j‖)

এখানে r_i · r_j হলো dot product (একই ক্রেতার দুই রেটিং গুণ করে যোগ), আর ‖r_i‖ vector-এর দৈর্ঘ্য। তারপর ক্রেতা u-এর পণ্য i-এর অনুমিত রেটিং হলো তাঁর রেট করা পণ্যগুলোর ভারযুক্ত গড়, ভার = মিল:

r̂_ui = ∑_{j ∈ N(i; u)} sim(i, j) · r_uj / ∑_{j ∈ N(i; u)} |sim(i, j)|

N(i; u) হলো u-এর রেট করা পণ্যগুলোর মধ্যে i-এর সবচেয়ে কাছের কয়েকটি। নিচের stepper পাঁচজন ক্রেতা আর চারটি পণ্য নিয়ে পুরো হিসাবটি করে।

বড় ডেটায় item-based CF সাধারণত user-based-এর চেয়ে সুবিধাজনক। পণ্যের সংখ্যা প্রায়ই ক্রেতার চেয়ে কম, আর দুই পণ্যের মিল ধীরে বদলায়, তাই item × item মিলের সারণি আগে থেকে হিসাব করে রাখা যায়। নিচের ব্লক implicit রূপে (কিনেছেন = ১, না = ০) item-based CF লেখে: প্রতিটি পণ্যের score হলো ক্রেতার কেনা পণ্যগুলোর সঙ্গে তার মিলের যোগফল, যা গোটা matrix-এ এক গুণে হয়: M @ S. এই ব্লক আর পরের দুটি একই namespace ভাগ করে (data-shared).

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from bazar_rec import make_ratings, split_last, CATS

df, cat = make_ratings()                     # user, item, rating (1–5), day
nU, nI = 300, 120
print(df.head(3).to_string(index=False))
print(f"ratings: {len(df)} | cells: {nU * nI} | sparsity: {1 - len(df) / (nU * nI):.1%}")
tr, te = split_last(df)                      # প্রত্যেকের শেষ কেনা লুকানো (অংশ ৬)
R = np.zeros((nU, nI)); M = np.zeros((nU, nI))
R[tr.user, tr["item"]] = tr.rating; M[tr.user, tr["item"]] = 1
cnt = M.sum(0)                               # প্রতিটি পণ্য কতজন কিনেছেন
top6 = np.argsort(-cnt, kind="stable")[:6]   # সবচেয়ে জনপ্রিয় ৫% (৬টি) পণ্য
print(f"top 5% items get {cnt[top6].sum() / cnt.sum():.0%} of purchases")

def item_cf(M):                              # item-based CF, cosine
    n = np.linalg.norm(M, axis=0) + 1e-9
    S = (M.T @ M) / np.outer(n, n)
    np.fill_diagonal(S, 0)
    return M @ S                             # score = কেনা পণ্যগুলোর সঙ্গে মিলের যোগ

CF = item_cf(M)
u = 11
seen = np.flatnonzero(M[u])
print("user 11 bought:", pd.Series(CATS[cat[seen]]).value_counts().to_dict())
for name, s in [("popularity", cnt.copy()), ("item-CF", CF[u].copy())]:
    s[seen] = -np.inf                        # আগে কেনা পণ্য বাদ
    rec = np.argsort(-s, kind="stable")[:5]
    print(f"{name:10s} → {rec} {CATS[cat[rec]].tolist()}")

fig, ax = plt.subplots(figsize=(6, 2.6), layout="constrained")
ax.bar(range(nI), np.sort(cnt)[::-1], color="C0")
ax.set(xlabel="item rank", ylabel="buyers (train)", title="Long tail of item popularity")
plt.show()

 user  item  rating  day
    0    56       3   18
    0    20       4   50
    0   116       4   52
ratings: 3529 | cells: 36000 | sparsity: 90.2%
top 5% items get 23% of purchases
user 11 bought: {'book': 9}
popularity → [ 49 113  66  14  56] ['gadget', 'gadget', 'beauty', 'beauty', 'grocery']
item-CF    → [51 31 47 19 27] ['book', 'book', 'book', 'book', 'book']

৩ · Matrix factorization — রুচির গোপন অক্ষ, শুধু জানা ঘরে শেখা

Neighbourhood পদ্ধতি সরল আর ব্যাখ্যা করা সহজ (“আপনি এটি কিনেছেন, তাই এটি”), কিন্তু দুটি দুর্বলতা আছে: খুব বিরল পণ্যের মিল নির্ভরযোগ্য নয়, আর মিলগুলো জোড়ায় জোড়ায় হিসাব হয়, কোনো সার্বিক কাঠামো শেখে না। Matrix factorization (MF) ভিন্নভাবে ভাবে: প্রত্যেক ক্রেতা u-কে k-মাত্রার একটি vector p_u আর প্রতিটি পণ্য i-কে একটি q_i দেওয়া হয়, যাতে তাদের dot product রেটিং ব্যাখ্যা করে। এই k-টি মাত্রা হলো latent factor: কেউ নাম দেয়নি, ডেটা থেকে বেরিয়ে আসে (পর্ব ০৯-এর “মুদি বনাম গ্যাজেট” অক্ষের মতো)।

বাস্তব রেটিংয়ের বড় অংশ কোনো “রুচি” নয়, সাধারণ প্রবণতা: কেউ সব কিছুতে ৫ দেন, কিছু পণ্য সবার ভালো লাগে। তাই অনুমানে চারটি অংশ রাখা হয় (Koren, Bell আর Volinsky ২০০৯ সালে এই রূপটি জনপ্রিয় করেন):

r̂_ui = μ + b_u + b_i + p_uᵀq_i

μ সব রেটিংয়ের গড়, b_u ক্রেতার নিজস্ব ঝোঁক (উদার হলে ধনাত্মক), b_i পণ্যের নিজস্ব মান, আর p_uᵀq_i রুচি আর পণ্যের মিলের অংশ। শেখা হয় শুধু জানা ঘরের সেট K-এর ওপর, regularization-সহ:

min ∑_{(u,i) ∈ K} (r_ui − r̂_ui)² + λ (‖p_u‖² + ‖q_i‖² + b_u² + b_i²)

λ ছাড়া কী হয়? যে ক্রেতার রেটিং মাত্র দুটি, তাঁর জন্য k = ৪ মাত্রার vector যেকোনো দিকে যেতে পারে, দুটি ঘর হুবহু মিলিয়ে বাকি সব অনুমান উল্টাপাল্টা করে। L2 শাস্তি (পর্ব ১৭-এ দেখেছেন, এটি ০-কেন্দ্রিক Gaussian prior-এর MAP) কম তথ্যের ক্রেতাকে গড়ের দিকে টেনে রাখে। আর তথ্য বাড়লে শাস্তির ভূমিকা নিজে থেকেই কমে।

এই loss কমানোর দুটি প্রধান পথ। SGD (পর্ব ১৩): একটি জানা রেটিং নিয়ে ভুল e = r − r̂ বের করে p_u ← p_u + η(e·q_i − λp_u), q_i-তেও একইভাবে; Netflix Prize-এর সময় Simon Funk-এর ব্লগ থেকে এই পথ ছড়ায় (পর্ব ০৯-এ গল্পটি আছে)। ALS (alternating least squares): Q স্থির রাখলে loss p_u-এর সাপেক্ষে একটি সাধারণ ridge regression, যার সমাধান এক লাইনে; তারপর P স্থির রেখে Q, পালাক্রমে। প্রতিটি ধাপে loss কমে বা একই থাকে, learning rate বাছতে হয় না, আর প্রতিটি ক্রেতার সমাধান আলাদা বলে অনেক মেশিনে ভাগ করা সহজ।

৪ · ALS ধাপে ধাপে — একটি ক্রেতার vector হালনাগাদ

Q স্থির থাকলে ক্রেতা u-এর জন্য সমস্যাটি: Q_u (তিনি যে পণ্যগুলো রেট করেছেন, শুধু সেগুলোর q-এর সারি) আর তাঁর রেটিং r_u দিয়ে min ‖r_u − Q_up‖² + λ‖p‖². Gradient শূন্য ধরে পাওয়া যায়

p_u = (Q_uᵀQ_u + λI)⁻¹ Q_uᵀ r_u

I হলো identity matrix. এটি হুবহু ridge regression-এর সূত্র, যেখানে “feature” হলো পণ্যের factor আর “লক্ষ্য” ক্রেতার রেটিং। Bias রাখতে চাইলে q-এর শেষে একটি ১ জুড়ে দেওয়া হয়, তখন p-এর শেষ উপাদানটিই b_u. নিচের stepper k = ২ নিয়ে একটি হালনাগাদ হাতে করে।

নিচের ব্লক পুরো ALS bias-সহ লেখে। solve_side একবারে সব ক্রেতার (বা সব পণ্যের) ছোট ridge সমস্যা সমাধান করে: np.einsum প্রতিটি সারির জন্য আলাদা A matrix বানায় (mask M দিয়ে শুধু জানা ঘর), আর np.linalg.solve সবগুলো একসঙ্গে সমাধান করে। k = ৪ আর λ = ৫ আগে থেকে ঠিক করা, এই লুকানো ডেটায় খুঁজে বের করা নয়। তুলনার জন্য তিনটি মাপকাঠি: শুধু গড়, গড় + bias, আর শূন্য-ভরা SVD.

import numpy as np
import matplotlib.pyplot as plt

k, lam, mu = 4, 5.0, tr.rating.mean()        # factor ৪টি, L2 শক্তি λ = 5
rmse = lambda e: np.sqrt(np.mean(e ** 2))

def solve_side(F, Mx, T):                    # প্রতিটি সারির জন্য ridge: (FᵀF + λI)⁻¹Fᵀt
    X = np.hstack([F, np.ones((len(F), 1))])  # শেষ কলাম = নিজের bias
    A = np.einsum("ui,ik,il->ukl", Mx, X, X) + lam * np.eye(k + 1)
    W = np.linalg.solve(A, ((T * Mx) @ X)[..., None])[..., 0]
    return W[:, :k], W[:, k]

rng = np.random.default_rng(0)
P, Q = rng.normal(0, 0.1, (nU, k)), rng.normal(0, 0.1, (nI, k))
bu, bi, hist = np.zeros(nU), np.zeros(nI), []
for ep in range(15):
    P, bu = solve_side(Q, M, R - mu - bi)            # Q স্থির, ক্রেতার দিক
    Q, bi = solve_side(P, M.T, (R - mu - bu[:, None]).T)  # P স্থির, পণ্যের দিক
    pred = mu + bu[:, None] + bi + P @ Q.T
    hist.append((rmse((pred - R)[M > 0]), rmse(pred[te.user, te["item"]] - te.rating)))
    if ep in (0, 1, 4, 14): print(f"epoch {ep + 1:2d}  train {hist[-1][0]:.3f}  val {hist[-1][1]:.3f}")

bu0 = ((R - mu) * M).sum(1) / (M.sum(1) + lam)        # শুধু bias, factor নেই
bi0 = ((R - mu - bu0[:, None]) * M).sum(0) / (M.sum(0) + lam)
print("val, global mean only :", round(rmse(mu - te.rating), 3))
print("val, mean + biases    :", round(rmse(mu + bu0[te.user] + bi0[te["item"]] - te.rating), 3))
U, s, Vt = np.linalg.svd(R, full_matrices=False)    # ভুল পথ: খালি ঘর = 0
Rk = (U[:, :k] * s[:k]) @ Vt[:k]
print("val, SVD of zero-filled:", round(rmse(Rk[te.user, te["item"]] - te.rating), 3),
      "| mean prediction", round(Rk[te.user, te["item"]].mean(), 2))
fig, ax = plt.subplots(figsize=(6, 2.8), layout="constrained")
ax.plot(range(1, 16), [h[0] for h in hist], "o-", label="train RMSE")
ax.plot(range(1, 16), [h[1] for h in hist], "s-", label="validation RMSE")
ax.set(xlabel="ALS epoch", ylabel="RMSE", title="Matrix factorization with biases (ALS)")
ax.legend(); plt.show()

epoch  1  train 0.850  val 0.991
epoch  2  train 0.687  val 0.947
epoch  5  train 0.615  val 0.908
epoch 15  train 0.594  val 0.884
val, global mean only : 1.284
val, mean + biases    : 0.993
val, SVD of zero-filled: 2.822 | mean prediction 1.09

৫ · Implicit feedback — weighted matrix factorization

বাজারঘরের মতো দোকানে রেটিং দেন অল্প কয়েকজন, কিন্তু কেনা, কার্টে রাখা আর পাতা দেখার হিসাব থাকে সবার। এই implicit ডেটায় খালি ঘরকে বাদ দেওয়া যায় না, কারণ তখন শুধু ১ থাকে আর মডেল সবকিছুতে ১ অনুমান করে ভুল শূন্য করে ফেলে। আবার খালি ঘরকে সমান গুরুত্বের “০” ধরাও ভুল, অংশ ৩-এর সমস্যা ফিরে আসে।

Hu, Koren আর Volinsky (২০০৮, ICDM) একটি মাঝামাঝি পথ দেন, যার নাম এখন weighted matrix factorization (WMF) বা implicit ALS. প্রতিটি ঘরে দুটি সংখ্যা: পছন্দ x_ui (কিনেছেন হলে ১, না হলে ০) আর আস্থা c_ui = ১ + α·(কতবার কিনেছেন বা দেখেছেন)। Loss সব ঘরের ওপর, কিন্তু ভারযুক্ত:

min ∑_u,i c_ui (x_ui − p_uᵀq_i)² + λ(∑‖p_u‖² + ∑‖q_i‖²)

না-কেনা ঘর “০” হিসেবে থাকে, কিন্তু ভার মাত্র ১; কেনা ঘরের ভার ১ + α, তাই অনেক বেশি। অর্থাৎ মডেল বলে, “কিনেছেন, এ বিষয়ে আমি নিশ্চিত; না-কেনা থেকে সামান্য সন্দেহ”। সব ঘর loss-এ থাকায় SGD ধীর হয়ে যায়, কিন্তু ALS-এ একটি কৌশল আছে: Qᵀ C_u Q = QᵀQ + Qᵀ(C_u − I)Q, আর প্রথম অংশ সব ক্রেতার জন্য একই, দ্বিতীয় অংশে শুধু কেনা পণ্য লাগে। তাই বড় ডেটাতেও হিসাব চলে। আমাদের ছোট ডেটায় পরের ব্লক সরাসরি পুরো C দিয়েই হিসাব করে।

৬ · মূল্যায়ন — সময় মেনে leave-last-out, precision@k, recall@k আর NDCG

Recommender-এর আসল কাজ একটি তালিকা দেখানো, যেমন অ্যাপের প্রথম পাতায় ১০টি পণ্য। তাই প্রশ্ন “রেটিং কত কাছে অনুমান হলো” নয়, “ক্রেতা পরে যা কিনলেন, তা তালিকার ওপরের দিকে ছিল কি না”। মূল্যায়নের নকশায় দুটি সিদ্ধান্ত।

কী লুকাবেন: এলোমেলো রেটিং লুকালে মডেল অনেক সময় “ভবিষ্যৎ” দেখে শেখে (মে মাসের কেনা দিয়ে মার্চের কেনা অনুমান), যা বাস্তবে কখনো হয় না; এটি data leakage-এর একটি রূপ। Leave-last-out প্রত্যেক ক্রেতার সময়ে শেষ ঘটনাটি লুকায়, আর বাকি সব দিয়ে শেখায়। আরও কড়া রূপ একটি তারিখ ধরে ভাগ করা (global time-based split): তারিখের আগের সব কিছু train, পরের সব test, যাতে কোনো ক্রেতার ক্ষেত্রেও অন্যের ভবিষ্যৎ ঢোকে না।

কী মাপবেন: ক্রেতা u-এর শীর্ষ k সুপারিশের তালিকায় প্রাসঙ্গিক (পরে সত্যিই কেনা) পণ্যের সংখ্যা h হলে

• Precision@k = h / k: তালিকার কত ভাগ কাজে লাগল।
• Recall@k = h / (মোট প্রাসঙ্গিক): প্রাসঙ্গিকের কত ভাগ তালিকায় ধরা পড়ল।
• MAP: প্রতিটি hit-এর অবস্থানে precision নিয়ে গড় (average precision), তারপর সব ক্রেতার গড়। প্রাসঙ্গিক একটি হলে এটি ১/অবস্থান, যাকে MRR বলে।
• NDCG@k: অবস্থান অনুযায়ী ছাড়: i-তম স্থানের প্রাসঙ্গিকতা rel_i-কে log₂(i + 1) দিয়ে ভাগ করে যোগ (DCG), তারপর সবচেয়ে ভালো সম্ভাব্য ক্রমের DCG (IDCG) দিয়ে ভাগ, যাতে মান ০ থেকে ১.

কয়েকটি বিষয় খেয়াল রাখুন। NDCG-এর আরেকটি প্রচলিত রূপে লাভ হিসেবে rel-এর বদলে 2^rel − 1 নেওয়া হয় (উঁচু প্রাসঙ্গিকতা আরও বেশি পুরস্কার পায়); এই উদাহরণে তাতে NDCG ০.৪৪৪. কোন রূপ ব্যবহার করলেন তা লিখে রাখুন, নইলে দুই পেপারের সংখ্যা তুলনীয় নয়। আর আগে কেনা পণ্য তালিকা থেকে বাদ দিন, নইলে মডেল “আপনি যা কিনেছেন তা-ই আবার” দেখিয়ে সহজ নম্বর পায় (যদিও চাল-ডালের মতো বারবার কেনা পণ্যে আবার দেখানো ঠিকই কাজের, সেটি আলাদা প্রশ্ন)।

৭ · চার পদ্ধতির তুলনা — নির্ভুলতা, coverage আর popularity bias

এখন চারটি পদ্ধতি একই লুকানো শেষ কেনার ওপর: popularity, item-CF (ব্লক ১), রেটিংয়ে শেখা bias-সহ MF (ব্লক ২-এর pred), আর কেনা-না-কেনা থেকে শেখা WMF. প্রত্যেক ক্রেতার প্রাসঙ্গিক পণ্য একটি (শেষ কেনা), তাই IDCG = ১, NDCG = ১/log₂(অবস্থান + ১), আর precision@10 সবসময় recall@10-এর দশ ভাগের এক ভাগ। নির্ভুলতার পাশে দুটি স্বাস্থ্য-মাপ: catalog coverage (সব ক্রেতার তালিকা মিলিয়ে কত ভাগ পণ্য অন্তত একবার এসেছে) আর সুপারিশের কত ভাগ শীর্ষ ৫% জনপ্রিয় পণ্যে গেছে, যা popularity bias-এর একটি সরল মাপ।

import numpy as np

def top_n(S, n=10):                          # আগে কেনা পণ্য বাদ দিয়ে শীর্ষ n
    S = np.where(M > 0, -np.inf, S)
    return np.argsort(-S, axis=1, kind="stable")[:, :n]

def rank_metrics(rec, te):                   # প্রতি ক্রেতার প্রাসঙ্গিক পণ্য ১টি
    hit = rec[te.user] == te["item"].to_numpy()[:, None]
    pos = hit.argmax(1)                      # কত নম্বরে এল (0 থেকে)
    ndcg = np.where(hit.any(1), 1 / np.log2(pos + 2), 0.0)  # IDCG = 1
    return hit.sum(1).mean() / 10, hit.any(1).mean(), ndcg.mean()

def wmf(k=4, lam=1.0, alpha=10.0, epochs=10):  # implicit ALS (Hu, Koren, Volinsky)
    C, g = 1 + alpha * M, np.random.default_rng(0)
    Pi, Qi = g.normal(0, 0.1, (nU, k)), g.normal(0, 0.1, (nI, k))
    for _ in range(epochs):
        A = np.einsum("ui,ik,il->ukl", C, Qi, Qi) + lam * np.eye(k)
        Pi = np.linalg.solve(A, ((C * M) @ Qi)[..., None])[..., 0]
        A = np.einsum("ui,uk,ul->ikl", C, Pi, Pi) + lam * np.eye(k)
        Qi = np.linalg.solve(A, ((C * M).T @ Pi)[..., None])[..., 0]
    return Pi @ Qi.T

models = {"popularity": np.tile(cnt, (nU, 1)), "item-CF": CF,
          "MF (ratings)": pred, "WMF (implicit)": wmf()}
print(f"{'model':15s} P@10   R@10   NDCG@10 coverage top5%")
for name, S in models.items():
    rec = top_n(S)
    p, r, nd = rank_metrics(rec, te)
    cov = len(np.unique(rec)) / nI           # কত ভাগ পণ্য অন্তত একবার সুপারিশে এল
    share = np.isin(rec, top6).mean()        # সুপারিশের কত ভাগ শীর্ষ ৫% পণ্যে
    print(f"{name:15s} {p:.3f}  {r:.3f}  {nd:.3f}   {cov:.2f}     {share:.2f}")

model           P@10   R@10   NDCG@10 coverage top5%
popularity      0.024  0.240  0.121   0.16     0.35
item-CF         0.057  0.567  0.329   0.77     0.17
MF (ratings)    0.025  0.250  0.135   0.44     0.04
WMF (implicit)  0.056  0.560  0.304   0.78     0.12

Offline মাপের সীমাও মনে রাখুন। লুকানো শেষ কেনা ঘটেছিল পুরোনো ব্যবস্থার অধীনে, যা হয়তো জনপ্রিয় পণ্যই বেশি দেখিয়েছিল; তাই offline মাপ জনপ্রিয় পণ্যের দিকে ঝুঁকে থাকে। নতুন মডেল যদি একটি অদেখা কিন্তু দারুণ পণ্য দেখায়, offline হিসাবে সেটি “ভুল”, কারণ ক্রেতা তা কেনার সুযোগই পাননি। চূড়ান্ত বিচার তাই অনলাইন A/B test (পর্ব ৬২ আর ৬৩-এ আসবে), আর offline মাপ প্রার্থী বাছাইয়ের ছাঁকনি।

৮ · Cold start, content-based আর hybrid

নতুন ক্রেতা সাইন-আপ করলেন, কিছু কেনেননি। CF তাঁর জন্য কিছুই জানে না: item-CF-এ যোগ করার মতো কেনা পণ্য নেই, MF-এ p_u শেখার মতো রেটিং নেই। নতুন পণ্যেরও একই দশা। এটাই cold start. তিনটি প্রচলিত উত্তর।

নিচের ব্লক একটি পরীক্ষা সাজায়: ক্রেতা ০–২৩৯ “পুরোনো”, তাঁদের কেনা থেকে জনপ্রিয়তা আর item-item মিল; ক্রেতা ২৪০–২৯৯ “নতুন”, যাঁদের শুধু প্রথম কেনাটি জানা। প্রশ্ন: সেই এক তথ্য থেকে তাঁদের পরের কেনাগুলোর কত ভাগ শীর্ষ ১০-এ ধরা যায় (recall@10)? Content হিসেবে শুধু পণ্যের বিভাগ ব্যবহার হয়েছে।

import numpy as np
import pandas as pd
from bazar_rec import make_ratings

df, cat = make_ratings()
old, new = df[df.user < 240], df[df.user >= 240]           # ৬০ জন নতুন ক্রেতা
M = np.zeros((240, 120)); M[old.user, old["item"]] = 1
pop = M.sum(0)                                              # পুরোনোদের থেকে জনপ্রিয়তা
nrm = np.linalg.norm(M, axis=0) + 1e-9
S = (M.T @ M) / np.outer(nrm, nrm); np.fill_diagonal(S, 0)  # item-item cosine
onehot = np.eye(4)[cat]                                     # content: পণ্যের বিভাগ

res = {"popularity": [], "content (category)": [], "item-CF (1 item)": [], "hybrid": []}
for u, g in new.sort_values("day").groupby("user"):
    first, rest = g["item"].iloc[0], set(g["item"].iloc[1:])
    scores = {"popularity": pop.copy(),
              "content (category)": onehot @ onehot[first] * 1000 + pop,
              "item-CF (1 item)": S[first] + 1e-6 * pop,
              "hybrid": S[first] / S[first].max() + onehot @ onehot[first] + pop / pop.max()}
    for name, s in scores.items():
        s[first] = -np.inf
        top = np.argsort(-s, kind="stable")[:10]
        res[name].append(len(rest & set(top)) / len(rest))   # recall@10
for name, r in res.items():
    print(f"{name:20s} recall@10 = {np.mean(r):.3f}")

popularity           recall@10 = 0.288
content (category)   recall@10 = 0.416
item-CF (1 item)     recall@10 = 0.364
hybrid               recall@10 = 0.417

৯ · বাস্তবের recommender — দুই ধাপ, embedding আর একটু ইতিহাস

লাখো পণ্যের দোকানে প্রতি ক্রেতার জন্য সব পণ্যের score হিসাব করা ধীর। তাই বাস্তব ব্যবস্থা সাধারণত দুই ধাপে চলে। Retrieval (candidate generation): দ্রুত কয়েকশো সম্ভাব্য পণ্য বাছাই, যেমন item-CF-এর সারণি থেকে, বা ক্রেতা আর পণ্যের vector-এর dot product দিয়ে approximate nearest neighbour খোঁজ, যার মূল ধারণা AI-এর ভিত্তি কোর্সের পর্ব ৬৯-এ দেখেছেন। Ranking: সেই কয়েকশোকে একটি সমৃদ্ধ মডেল দিয়ে সাজানো, যেখানে সময়, দাম, ডেলিভারির এলাকা, স্টকের মতো feature ঢোকে; প্রায়ই gradient boosting (পর্ব ৩৫)। শেষে ব্যবসার নিয়ম: স্টক নেই এমন পণ্য বাদ, একই বিভাগের সব নয়।

MF-এর p_u আর q_i আসলে embedding. পরবর্তী ধাপে দুটি neural network দিয়ে ক্রেতা আর পণ্যের feature থেকে embedding বানানো হয়, যার নাম two-tower model; নতুন পণ্যের বিবরণ থেকেও তার vector আসে বলে cold start কমে। Covington ও সহকর্মীদের (২০১৬) YouTube-এর প্রবন্ধ এই দুই ধাপের নকশার একটি বহুল উদ্ধৃত উদাহরণ। এগুলো ভবিষ্যতের deep learning কোর্সের বিষয়; এখানে মূল কথা: ভিত্তি একই dot product.

ইতিহাসের সংক্ষিপ্ত রূপরেখা, প্রচলিত বিবরণ অনুযায়ী: “collaborative filtering” শব্দটি Xerox PARC-এর Tapestry ব্যবস্থার প্রবন্ধে (Goldberg ও সহকর্মীরা, ১৯৯২) আসে; GroupLens (Resnick ও সহকর্মীরা, ১৯৯৪) সংবাদ-গোষ্ঠীর লেখায় user-based CF চালায়; Sarwar ও সহকর্মীরা (২০০১) item-based CF-এর পদ্ধতিগত তুলনা প্রকাশ করেন, আর Linden, Smith ও York (২০০৩) একটি বড় অনলাইন দোকানের item-to-item ব্যবস্থার বিবরণ দেন। ২০০৬–২০০৯-এর Netflix Prize matrix factorization-কে কেন্দ্রে আনে (পর্ব ০৯-এ বিস্তারিত)।

১০ · AI-এর যুগে — recommender-এর কোড আর মূল্যায়ন যাচাই

AI assistant কয়েক সেকেন্ডে একটি recommender লিখে দেয়, আর সংখ্যাগুলো প্রায়ই দারুণ দেখায়। সমস্যা সাধারণত লুকিয়ে থাকে মূল্যায়নে।

AI-এর দেওয়া recommender-এর কোড বা ফল হাতে পেলে — যাচাইয়ের চেকলিস্ট

• Loss শুধু জানা ঘরে (explicit) বা আস্থা-ভারসহ সব ঘরে (implicit), খালি ঘর নিছক ০ নয়, তা নিশ্চিত করেছি
• Train/test ভাগ সময় মেনে হয়েছে, আর test-এর কোনো ঘটনা similarity বা popularity হিসাবে ঢোকেনি
• ছোট একটি তালিকায় precision@k আর NDCG@k হাতে করে কোডের সঙ্গে মিলিয়েছি
• Popularity baseline-এর পাশে, পুরো ক্যাটালগে, কয়েকটি seed বা সময়-খণ্ডে তুলনা করেছি
• নির্ভুলতার পাশে coverage আর জনপ্রিয় পণ্যের ভাগ দেখেছি
• Library-র parameter নাম আর ডিফল্ট নিজের version-এর অফিসিয়াল docs-এ মিলিয়েছি
• আসল ক্রেতার কেনাকাটা বা পরিচয়ের তথ্য AI-তে পেস্ট করিনি