Spaces:
Running
Running
Download src/serving.py from alllukaaa/game-recommender: direct link, hf CLI and curl.
- Browser
- Download file 5.64 kB
-
https://huggingface.co/spaces/alllukaaa/game-recommender/resolve/main/src/serving.py
- Command line
-
hf download hf://spaces/alllukaaa/game-recommender/src/serving.py
-
curl -L -o serving.py https://huggingface.co/spaces/alllukaaa/game-recommender/resolve/main/src/serving.py
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] | |