game-recommender / src /serving.py
alllukaaa's picture
Upload folder using huggingface_hub
9ef5e72 verified
Raw History Blame Contribute Delete
5.64 kB
"""Request path of the recommendation service: Two-Tower candidates from Qdrant re-ranked by LightGBM.
Standalone on purpose (numpy, pandas, lightgbm, qdrant-client only), so the FastAPI image needs just this file
and models/. The collection must be loaded first: `python -m src.load_qdrant`.
recommender = Recommender("models", "http://localhost:6333") # once, at startup
recommender.recommend([{"app_id": 730, "playtime": 812.5, "is_recommended": True}], top_k=10)
"""
import json
from pathlib import Path
import lightgbm as lgb
import numpy as np
import pandas as pd
from qdrant_client import QdrantClient, models
class Recommender:
def __init__(self, models_dir="models", qdrant_url="http://localhost:6333", api_key=None, collection="games"):
models_dir = Path(models_dir)
self.manifest = json.loads((models_dir / "manifest.json").read_text(encoding="utf-8"))
self.side = dict(np.load(models_dir / "user_side.npz"))
self.ranker = lgb.Booster(model_file=str(models_dir / "ranker.txt"))
self.client = QdrantClient(url=qdrant_url, api_key=api_key or None)
self.collection = collection
def recommend(self, history: list, top_k: int = 10) -> list:
"""history: [{"app_id", "playtime" (hours), "is_recommended"}], oldest first.
Returns [{"app_id", "title", "score", "price", "tags"}]; score is None for the popularity fallback,
used when none of the games in `history` is in the catalog.
"""
request = pd.DataFrame(history, columns=["app_id", "playtime", "is_recommended"])
request = request[request["app_id"] > 0].drop_duplicates("app_id", keep="last")
ids = request["app_id"].astype(int).tolist()
records = {r.id: r for r in self.client.retrieve(self.collection, ids=ids, with_vectors=True,
with_payload=["tags"])} if ids else {}
known = request[request["app_id"].isin(list(records))]
if known.empty:
return self.fallback(set(ids), top_k)
weights = 1 + np.log1p(known["playtime"].to_numpy(float).clip(min=0))
liked = known["is_recommended"].to_numpy(bool)
games = [records[a] for a in known["app_id"]]
# user tower on the last max_len games
last = slice(-self.manifest["max_len"], None)
h = np.array([g.vector["two_tower"] for g in games])[last] + self.side["liked_embedding"][liked[last].astype(int)]
u = (h * weights[last, None]).sum(0) / max(weights[last].sum(), 1e-6)
u = np.maximum(u @ self.side["mlp1_weight"].T + self.side["mlp1_bias"], 0)
u = u @ self.side["mlp2_weight"].T + self.side["mlp2_bias"]
u = u / max(np.linalg.norm(u), 1e-12)
points = self.client.query_points(
self.collection, query=u.tolist(), using="two_tower", limit=self.manifest["n_candidates"],
query_filter=models.Filter(must_not=[models.HasIdCondition(has_id=ids)]),
search_params=models.SearchParams(exact=True), with_payload=True, with_vectors=["als", "text"]).points
# ALS factor of the new user from its liked games
als_score = np.full(len(points), np.nan)
with_als = [(g, w) for g, w, l in zip(games, weights, liked) if l and "als" in g.vector]
if with_als:
Y = np.array([g.vector["als"] for g, _ in with_als])
c = self.manifest["als"]["alpha"] * np.array([w for _, w in with_als])
A = self.side["als_yty"] + self.manifest["als"]["regularization"] * np.eye(Y.shape[1]) + (Y.T * (c - 1)) @ Y
x = np.linalg.solve(A, (c[:, None] * Y).sum(0))
als_score = np.array([np.dot(p.vector["als"], x) if "als" in p.vector else np.nan for p in points])
tag_overlap = text_similarity = np.full(len(points), np.nan)
liked_games = [g for g, l in zip(games, liked) if l]
if liked_games:
profile = np.mean([g.vector["text"] for g in liked_games], axis=0)
text_similarity = np.array([p.vector["text"] for p in points]) @ (profile / np.linalg.norm(profile))
liked_tags = set().union(*(g.payload["tags"] for g in liked_games))
tag_overlap = np.array([len(set(p.payload["tags"]) & liked_tags) / max(len(p.payload["tags"]), 1)
for p in points])
features = pd.DataFrame({
"tt_score": [p.score for p in points],
"tt_rank": np.arange(len(points)),
"als_score": als_score,
**{name: [p.payload[name] for p in points] for name in
("log_reviews", "log_recent_reviews", "positive_share", "log_price", "log_age_days")},
"tag_overlap": tag_overlap,
"text_similarity": text_similarity,
"log_history_len": np.log1p(len(known)),
})[self.manifest["ranker_features"]]
scores = self.ranker.predict(features)
order = np.argsort(-scores, kind="stable")[:top_k]
return [{"app_id": points[i].id, "title": points[i].payload["title"], "score": float(scores[i]),
"price": points[i].payload["price"], "tags": points[i].payload["tags"]} for i in order]
def fallback(self, seen: set, top_k: int) -> list:
ids = [a for a in self.manifest["fallback_app_ids"] if a not in seen][:top_k]
points = {p.id: p for p in self.client.retrieve(self.collection, ids=ids, with_payload=True)}
return [{"app_id": a, "title": points[a].payload["title"], "score": None,
"price": points[a].payload["price"], "tags": points[a].payload["tags"]} for a in ids if a in points]