[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M79AJ37YR7Y5XB6AE8JDMVRY":3,"skill-same:01M79AJ37YR7Y5XB6AE8JDMVRY":64},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":26,"commitSha":27,"skillDirectory":28,"forksCount":14,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":31,"install":32,"resources":45},"01M79AJ37YR7Y5XB6AE8JDMVRY","recommendation-engine",null,"Build recommendation systems with collaborative filtering, matrix factorization, hybrid approaches. Use for product recommendations, personalization, or encountering cold start, sparsity, quality evaluation issues.","Elogic360\u002Fsoftware-factory","Elogic360","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F156535519?v=4","01M74NH3F0RB13PWB7JZDE2V80","elogic360","01M74NH3FPC65082MDZVMFHDM3",0,"MIT","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fintegrations\u002Fclaude-skills-secondsky\u002Fplugins\u002Frecommendation-engine\u002Fskills\u002Frecommendation-engine\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: recommendation-engine\ndescription: Build recommendation systems with collaborative filtering, matrix factorization, hybrid approaches. Use for product recommendations, personalization, or encountering cold start, sparsity, quality evaluation issues.\nlicense: MIT\nmetadata:\n  keywords: \"recommendation engine, collaborative filtering, matrix factorization, SVD, ALS, NMF, user-based CF, item-based CF, cold start, precision@k, recall@k, NDCG, hybrid recommender, content-based filtering, cosine similarity, implicit feedback, evaluation metrics, diversity, coverage\"\n---\n\n# Recommendation Engine\n\nBuild recommendation systems for personalized content and product suggestions.\n\n## Recommendation Approaches\n\n| Approach | How It Works | Pros | Cons |\n|----------|--------------|------|------|\n| Collaborative | User-item interactions | Discovers hidden patterns | Cold start |\n| Content-based | Item features | Works for new items | Limited discovery |\n| Hybrid | Combines both | Best of both | Complex |\n\n## Collaborative Filtering\n\n```python\nimport numpy as np\nfrom scipy.sparse import csr_matrix\nfrom sklearn.metrics.pairwise import cosine_similarity\n\nclass CollaborativeFilter:\n    def __init__(self):\n        self.user_similarity = None\n        self.item_similarity = None\n\n    def fit(self, user_item_matrix):\n        # User-based similarity\n        self.user_similarity = cosine_similarity(user_item_matrix)\n        # Item-based similarity\n        self.item_similarity = cosine_similarity(user_item_matrix.T)\n\n    def recommend_for_user(self, user_id, n=10):\n        scores = self.user_similarity[user_id].dot(self.user_item_matrix)\n        # Exclude already interacted items\n        already_interacted = self.user_item_matrix[user_id].nonzero()[0]\n        scores[already_interacted] = -np.inf\n        return np.argsort(scores)[-n:][::-1]\n```\n\n## Matrix Factorization (SVD)\n\n```python\nfrom sklearn.decomposition import TruncatedSVD\n\nclass MatrixFactorization:\n    def __init__(self, n_factors=50):\n        self.svd = TruncatedSVD(n_components=n_factors)\n\n    def fit(self, user_item_matrix):\n        self.user_factors = self.svd.fit_transform(user_item_matrix)\n        self.item_factors = self.svd.components_.T\n\n    def predict(self, user_id, item_id):\n        return np.dot(self.user_factors[user_id], self.item_factors[item_id])\n```\n\n## Hybrid Recommender\n\n```python\nclass HybridRecommender:\n    def __init__(self, collab_weight=0.7, content_weight=0.3):\n        self.collab = CollaborativeFilter()\n        self.content = ContentBasedFilter()\n        self.weights = (collab_weight, content_weight)\n\n    def recommend(self, user_id, n=10):\n        collab_scores = self.collab.score(user_id)\n        content_scores = self.content.score(user_id)\n        combined = self.weights[0] * collab_scores + self.weights[1] * content_scores\n        return np.argsort(combined)[-n:][::-1]\n```\n\n## Evaluation Metrics\n\n- Precision@K, Recall@K\n- NDCG (ranking quality)\n- Coverage (catalog diversity)\n- A\u002FB test conversion rate\n\n## Cold Start Solutions\n\n- **New users**: Popular items, onboarding preferences, demographic-based\n- **New items**: Content-based bootstrapping, active learning\n- **Exploration strategies**: ε-greedy, Thompson sampling bandits\n\n## Quick Start: Build a Recommender in 5 Steps\n\n```python\nfrom scipy.sparse import csr_matrix\nimport numpy as np\n\n# 1. Prepare user-item interaction matrix\n# rows = users, cols = items, values = ratings\u002Finteractions\nratings_data = [(0, 5, 5), (0, 10, 4), (1, 5, 3), ...]  # (user, item, rating)\nn_users, n_items = 1000, 5000\n\nrow_idx = [r[0] for r in ratings_data]\ncol_idx = [r[1] for r in ratings_data]\nratings = [r[2] for r in ratings_data]\nuser_item_matrix = csr_matrix((ratings, (row_idx, col_idx)), shape=(n_users, n_items))\n\n# 2. Choose and train model\nfrom recommendation_engine import ItemBasedCollaborativeFilter  # See references\n\nmodel = ItemBasedCollaborativeFilter(similarity_metric='cosine', k_neighbors=20)\nmodel.fit(user_item_matrix)\n\n# 3. Generate recommendations\nrecommendations = model.recommend(user_id=42, n=10)\nprint(recommendations)  # [(item_id, score), ...]\n\n# 4. Evaluate on test set\nfrom evaluation_metrics import precision_at_k, recall_at_k\n\ntest_items = {42: {10, 25, 30}}  # True relevant items for user 42\nrec_items = [item for item, score in recommendations]\n\nprecision = precision_at_k(rec_items, test_items[42], k=10)\nrecall = recall_at_k(rec_items, test_items[42], k=10)\nprint(f\"Precision@10: {precision:.3f}, Recall@10: {recall:.3f}\")\n\n# 5. Handle cold start\nfrom cold_start import PopularityRecommender\n\npopularity_model = PopularityRecommender()\npopularity_model.fit(interactions_with_timestamps)\nnew_user_recs = popularity_model.recommend(n=10)\n```\n\n## Known Issues Prevention\n\n### 1. Popularity Bias\n**Problem**: Recommending only popular items, ignoring long tail. Reduces diversity and serendipity.\n\n**Solution**: Balance popularity with personalization, apply re-ranking for diversity:\n```python\ndef diversify_recommendations(\n    recommendations: List[Tuple[int, float]],\n    item_features: np.ndarray,\n    diversity_weight: float = 0.3\n) -> List[Tuple[int, float]]:\n    \"\"\"Re-rank to increase diversity while maintaining relevance.\"\"\"\n    from sklearn.metrics.pairwise import cosine_distances\n\n    selected = []\n    candidates = recommendations.copy()\n\n    while len(selected) \u003C len(recommendations) and candidates:\n        if not selected:\n            # First item: highest score\n            selected.append(candidates.pop(0))\n            continue\n\n        # Compute diversity scores\n        selected_features = item_features[[item for item, _ in selected]]\n        diversity_scores = []\n\n        for item, relevance in candidates:\n            item_feature = item_features[item].reshape(1, -1)\n            # Average distance to already selected items\n            avg_distance = cosine_distances(item_feature, selected_features).mean()\n            # Combined score: relevance + diversity\n            combined = (1 - diversity_weight) * relevance + diversity_weight * avg_distance\n            diversity_scores.append((item, relevance, combined))\n\n        # Select item with best combined score\n        best = max(diversity_scores, key=lambda x: x[2])\n        selected.append((best[0], best[1]))\n        candidates = [(i, s) for i, s, _ in diversity_scores if i != best[0]]\n\n    return selected\n```\n\n### 2. Data Sparsity (Matrix >99% Empty)\n**Problem**: Collaborative filtering fails when most users have rated \u003C1% of items.\n\n**Solution**: Use matrix factorization (SVD, ALS) instead of memory-based CF:\n```python\n# ❌ Bad: User-based CF on sparse data (fails to find similar users)\nuser_cf = UserBasedCollaborativeFilter()\nuser_cf.fit(sparse_matrix)  # Most users have \u003C10 ratings\n\n# ✅ Good: Matrix factorization handles sparsity\nfrom sklearn.decomposition import TruncatedSVD\n\nsvd = TruncatedSVD(n_components=50)\nuser_factors = svd.fit_transform(sparse_matrix)\nitem_factors = svd.components_.T\n\n# Predict rating: user_factors[u] @ item_factors[i]\n```\n\n### 3. Cold Start Without Fallback\n**Problem**: Recommender crashes or returns empty results for new users\u002Fitems.\n\n**Solution**: Always implement fallback chain:\n```python\ndef recommend_with_fallback(user_id, n=10):\n    \"\"\"Graceful degradation through fallback chain.\"\"\"\n    try:\n        # Try personalized recommendations\n        if has_sufficient_history(user_id, min_interactions=5):\n            return collaborative_filter.recommend(user_id, n)\n    except Exception as e:\n        logger.warning(f\"CF failed for user {user_id}: {e}\")\n\n    # Fallback 1: Demographic-based\n    if user_demographics_available(user_id):\n        return demographic_recommender.recommend(user_id, n)\n\n    # Fallback 2: Popularity\n    return popularity_recommender.recommend(n)\n```\n\n### 4. Not Excluding Already-Interacted Items\n**Problem**: Recommending items user already purchased\u002Fviewed wastes recommendation slots.\n\n**Solution**: Always filter interacted items:\n```python\n# ✅ Correct: Exclude interacted items\nuser_items = user_item_matrix[user_id].nonzero()[1]\nscores[user_items] = -np.inf  # Ensure they don't appear in top-K\nrecommendations = np.argsort(scores)[-n:][::-1]\n\n# ❌ Wrong: Forgetting to filter\nrecommendations = np.argsort(scores)[-n:][::-1]  # May include already purchased!\n```\n\n### 5. Ignoring Implicit Feedback Confidence\n**Problem**: Treating all clicks\u002Fviews equally. 1 view ≠ 100 views.\n\n**Solution**: Weight by interaction strength (view count, watch time, etc.):\n```python\n# For implicit feedback, use confidence weighting\nconfidence_matrix = 1 + alpha * np.log(1 + interaction_counts)\n\n# In ALS: C_ui * (P_ui - X_ui)²\n# Higher confidence for items with more interactions\n```\n\n### 6. Not Evaluating Ranking Quality (Using Only Accuracy)\n**Problem**: High prediction accuracy (RMSE) doesn't mean good top-K recommendations.\n\n**Solution**: Use ranking metrics (NDCG, MAP@K):\n```python\n# ❌ Bad: Only RMSE\nfrom sklearn.metrics import mean_squared_error\nrmse = np.sqrt(mean_squared_error(y_true, y_pred))\n\n# ✅ Good: Ranking metrics for top-K evaluation\nfrom evaluation_metrics import ndcg_at_k, mean_average_precision_at_k\n\n# NDCG rewards putting highly relevant items first\nndcg = ndcg_at_k(recommendations, relevance_scores, k=10)\n\n# MAP@K considers precision at each relevant item position\nmap_score = mean_average_precision_at_k(all_recommendations, ground_truth, k=10)\n```\n\n### 7. Filter Bubble (Lack of Exploration)\n**Problem**: Always recommending similar items limits discovery, reduces user engagement over time.\n\n**Solution**: Implement explore-exploit strategy:\n```python\nclass ExploreExploitRecommender:\n    def __init__(self, base_model, epsilon=0.1):\n        self.base_model = base_model\n        self.epsilon = epsilon  # 10% exploration\n\n    def recommend(self, user_id, n=10):\n        # Exploit: Use trained model for most recommendations\n        n_exploit = int(n * (1 - self.epsilon))\n        exploitative_recs = self.base_model.recommend(user_id, n=n_exploit)\n\n        # Explore: Add random diverse items\n        n_explore = n - n_exploit\n        explored_items = sample_diverse_items(n_explore)\n\n        return exploitative_recs + explored_items\n```\n\n## When to Load References\n\nLoad reference files when you need detailed implementations:\n\n- **Collaborative Filtering**: Load `references\u002Fcollaborative-filtering-deep-dive.md` for complete user-based and item-based CF implementations with similarity metrics (cosine, Pearson, Jaccard), scalability optimizations (sparse matrices, approximate nearest neighbors), and handling edge cases (cold start, sparsity)\n\n- **Matrix Factorization**: Load `references\u002Fmatrix-factorization-methods.md` for SVD, ALS, and NMF implementations with hyperparameter tuning, implicit feedback handling, and advanced techniques (BPR, WARP)\n\n- **Evaluation Metrics**: Load `references\u002Fevaluation-metrics-implementation.md` for Precision@K, Recall@K, NDCG, coverage, diversity metrics, cross-validation strategies, and statistical significance testing (paired t-test, bootstrap confidence intervals)\n\n- **Cold Start Solutions**: Load `references\u002Fcold-start-strategies.md` for new user\u002Fitem strategies (popularity-based, onboarding, demographic, content-based bootstrapping, active learning), explore-exploit approaches (ε-greedy, Thompson sampling), and hybrid fallback chains\n","# Recommendation Engine\n\nBuild recommendation systems for personalized content and product suggestions.\n\n## Recommendation Approaches\n\n| Approach | How It Works | Pros | Cons |\n|----------|--------------|------|------|\n| Collaborative | User-item interactions | Discovers hidden patterns | Cold start |\n| Content-based | Item features | Works for new items | Limited discovery |\n| Hybrid | Combines both | Best of both | Complex |\n\n## Collaborative Filtering\n\n```python\nimport numpy as np\nfrom scipy.sparse import csr_matrix\nfrom sklearn.metrics.pairwise import cosine_similarity\n\nclass CollaborativeFilter:\n    def __init__(self):\n        self.user_similarity = None\n        self.item_similarity = None\n\n    def fit(self, user_item_matrix):\n        # User-based similarity\n        self.user_similarity = cosine_similarity(user_item_matrix)\n        # Item-based similarity\n        self.item_similarity = cosine_similarity(user_item_matrix.T)\n\n    def recommend_for_user(self, user_id, n=10):\n        scores = self.user_similarity[user_id].dot(self.user_item_matrix)\n        # Exclude already interacted items\n        already_interacted = self.user_item_matrix[user_id].nonzero()[0]\n        scores[already_interacted] = -np.inf\n        return np.argsort(scores)[-n:][::-1]\n```\n\n## Matrix Factorization (SVD)\n\n```python\nfrom sklearn.decomposition import TruncatedSVD\n\nclass MatrixFactorization:\n    def __init__(self, n_factors=50):\n        self.svd = TruncatedSVD(n_components=n_factors)\n\n    def fit(self, user_item_matrix):\n        self.user_factors = self.svd.fit_transform(user_item_matrix)\n        self.item_factors = self.svd.components_.T\n\n    def predict(self, user_id, item_id):\n        return np.dot(self.user_factors[user_id], self.item_factors[item_id])\n```\n\n## Hybrid Recommender\n\n```python\nclass HybridRecommender:\n    def __init__(self, collab_weight=0.7, content_weight=0.3):\n        self.collab = CollaborativeFilter()\n        self.content = ContentBasedFilter()\n        self.weights = (collab_weight, content_weight)\n\n    def recommend(self, user_id, n=10):\n        collab_scores = self.collab.score(user_id)\n        content_scores = self.content.score(user_id)\n        combined = self.weights[0] * collab_scores + self.weights[1] * content_scores\n        return np.argsort(combined)[-n:][::-1]\n```\n\n## Evaluation Metrics\n\n- Precision@K, Recall@K\n- NDCG (ranking quality)\n- Coverage (catalog diversity)\n- A\u002FB test conversion rate\n\n## Cold Start Solutions\n\n- **New users**: Popular items, onboarding preferences, demographic-based\n- **New items**: Content-based bootstrapping, active learning\n- **Exploration strategies**: ε-greedy, Thompson sampling bandits\n\n## Quick Start: Build a Recommender in 5 Steps\n\n```python\nfrom scipy.sparse import csr_matrix\nimport numpy as np\n\n# 1. Prepare user-item interaction matrix\n# rows = users, cols = items, values = ratings\u002Finteractions\nratings_data = [(0, 5, 5), (0, 10, 4), (1, 5, 3), ...]  # (user, item, rating)\nn_users, n_items = 1000, 5000\n\nrow_idx = [r[0] for r in ratings_data]\ncol_idx = [r[1] for r in ratings_data]\nratings = [r[2] for r in ratings_data]\nuser_item_matrix = csr_matrix((ratings, (row_idx, col_idx)), shape=(n_users, n_items))\n\n# 2. Choose and train model\nfrom recommendation_engine import ItemBasedCollaborativeFilter  # See references\n\nmodel = ItemBasedCollaborativeFilter(similarity_metric='cosine', k_neighbors=20)\nmodel.fit(user_item_matrix)\n\n# 3. Generate recommendations\nrecommendations = model.recommend(user_id=42, n=10)\nprint(recommendations)  # [(item_id, score), ...]\n\n# 4. Evaluate on test set\nfrom evaluation_metrics import precision_at_k, recall_at_k\n\ntest_items = {42: {10, 25, 30}}  # True relevant items for user 42\nrec_items = [item for item, score in recommendations]\n\nprecision = precision_at_k(rec_items, test_items[42], k=10)\nrecall = recall_at_k(rec_items, test_items[42], k=10)\nprint(f\"Precision@10: {precision:.3f}, Recall@10: {recall:.3f}\")\n\n# 5. Handle cold start\nfrom cold_start import PopularityRecommender\n\npopularity_model = PopularityRecommender()\npopularity_model.fit(interactions_with_timestamps)\nnew_user_recs = popularity_model.recommend(n=10)\n```\n\n## Known Issues Prevention\n\n### 1. Popularity Bias\n**Problem**: Recommending only popular items, ignoring long tail. Reduces diversity and serendipity.\n\n**Solution**: Balance popularity with personalization, apply re-ranking for diversity:\n```python\ndef diversify_recommendations(\n    recommendations: List[Tuple[int, float]],\n    item_features: np.ndarray,\n    diversity_weight: float = 0.3\n) -> List[Tuple[int, float]]:\n    \"\"\"Re-rank to increase diversity while maintaining relevance.\"\"\"\n    from sklearn.metrics.pairwise import cosine_distances\n\n    selected = []\n    candidates = recommendations.copy()\n\n    while len(selected) \u003C len(recommendations) and candidates:\n        if not selected:\n            # First item: highest score\n            selected.append(candidates.pop(0))\n            continue\n\n        # Compute diversity scores\n        selected_features = item_features[[item for item, _ in selected]]\n        diversity_scores = []\n\n        for item, relevance in candidates:\n            item_feature = item_features[item].reshape(1, -1)\n            # Average distance to already selected items\n            avg_distance = cosine_distances(item_feature, selected_features).mean()\n            # Combined score: relevance + diversity\n            combined = (1 - diversity_weight) * relevance + diversity_weight * avg_distance\n            diversity_scores.append((item, relevance, combined))\n\n        # Select item with best combined score\n        best = max(diversity_scores, key=lambda x: x[2])\n        selected.append((best[0], best[1]))\n        candidates = [(i, s) for i, s, _ in diversity_scores if i != best[0]]\n\n    return selected\n```\n\n### 2. Data Sparsity (Matrix >99% Empty)\n**Problem**: Collaborative filtering fails when most users have rated \u003C1% of items.\n\n**Solution**: Use matrix factorization (SVD, ALS) instead of memory-based CF:\n```python\n# ❌ Bad: User-based CF on sparse data (fails to find similar users)\nuser_cf = UserBasedCollaborativeFilter()\nuser_cf.fit(sparse_matrix)  # Most users have \u003C10 ratings\n\n# ✅ Good: Matrix factorization handles sparsity\nfrom sklearn.decomposition import TruncatedSVD\n\nsvd = TruncatedSVD(n_components=50)\nuser_factors = svd.fit_transform(sparse_matrix)\nitem_factors = svd.components_.T\n\n# Predict rating: user_factors[u] @ item_factors[i]\n```\n\n### 3. Cold Start Without Fallback\n**Problem**: Recommender crashes or returns empty results for new users\u002Fitems.\n\n**Solution**: Always implement fallback chain:\n```python\ndef recommend_with_fallback(user_id, n=10):\n    \"\"\"Graceful degradation through fallback chain.\"\"\"\n    try:\n        # Try personalized recommendations\n        if has_sufficient_history(user_id, min_interactions=5):\n            return collaborative_filter.recommend(user_id, n)\n    except Exception as e:\n        logger.warning(f\"CF failed for user {user_id}: {e}\")\n\n    # Fallback 1: Demographic-based\n    if user_demographics_available(user_id):\n        return demographic_recommender.recommend(user_id, n)\n\n    # Fallback 2: Popularity\n    return popularity_recommender.recommend(n)\n```\n\n### 4. Not Excluding Already-Interacted Items\n**Problem**: Recommending items user already purchased\u002Fviewed wastes recommendation slots.\n\n**Solution**: Always filter interacted items:\n```python\n# ✅ Correct: Exclude interacted items\nuser_items = user_item_matrix[user_id].nonzero()[1]\nscores[user_items] = -np.inf  # Ensure they don't appear in top-K\nrecommendations = np.argsort(scores)[-n:][::-1]\n\n# ❌ Wrong: Forgetting to filter\nrecommendations = np.argsort(scores)[-n:][::-1]  # May include already purchased!\n```\n\n### 5. Ignoring Implicit Feedback Confidence\n**Problem**: Treating all clicks\u002Fviews equally. 1 view ≠ 100 views.\n\n**Solution**: Weight by interaction strength (view count, watch time, etc.):\n```python\n# For implicit feedback, use confidence weighting\nconfidence_matrix = 1 + alpha * np.log(1 + interaction_counts)\n\n# In ALS: C_ui * (P_ui - X_ui)²\n# Higher confidence for items with more interactions\n```\n\n### 6. Not Evaluating Ranking Quality (Using Only Accuracy)\n**Problem**: High prediction accuracy (RMSE) doesn't mean good top-K recommendations.\n\n**Solution**: Use ranking metrics (NDCG, MAP@K):\n```python\n# ❌ Bad: Only RMSE\nfrom sklearn.metrics import mean_squared_error\nrmse = np.sqrt(mean_squared_error(y_true, y_pred))\n\n# ✅ Good: Ranking metrics for top-K evaluation\nfrom evaluation_metrics import ndcg_at_k, mean_average_precision_at_k\n\n# NDCG rewards putting highly relevant items first\nndcg = ndcg_at_k(recommendations, relevance_scores, k=10)\n\n# MAP@K considers precision at each relevant item position\nmap_score = mean_average_precision_at_k(all_recommendations, ground_truth, k=10)\n```\n\n### 7. Filter Bubble (Lack of Exploration)\n**Problem**: Always recommending similar items limits discovery, reduces user engagement over time.\n\n**Solution**: Implement explore-exploit strategy:\n```python\nclass ExploreExploitRecommender:\n    def __init__(self, base_model, epsilon=0.1):\n        self.base_model = base_model\n        self.epsilon = epsilon  # 10% exploration\n\n    def recommend(self, user_id, n=10):\n        # Exploit: Use trained model for most recommendations\n        n_exploit = int(n * (1 - self.epsilon))\n        exploitative_recs = self.base_model.recommend(user_id, n=n_exploit)\n\n        # Explore: Add random diverse items\n        n_explore = n - n_exploit\n        explored_items = sample_diverse_items(n_explore)\n\n        return exploitative_recs + explored_items\n```\n\n## When to Load References\n\nLoad reference files when you need detailed implementations:\n\n- **Collaborative Filtering**: Load `references\u002Fcollaborative-filtering-deep-dive.md` for complete user-based and item-based CF implementations with similarity metrics (cosine, Pearson, Jaccard), scalability optimizations (sparse matrices, approximate nearest neighbors), and handling edge cases (cold start, sparsity)\n\n- **Matrix Factorization**: Load `references\u002Fmatrix-factorization-methods.md` for SVD, ALS, and NMF implementations with hyperparameter tuning, implicit feedback handling, and advanced techniques (BPR, WARP)\n\n- **Evaluation Metrics**: Load `references\u002Fevaluation-metrics-implementation.md` for Precision@K, Recall@K, NDCG, coverage, diversity metrics, cross-validation strategies, and statistical significance testing (paired t-test, bootstrap confidence intervals)\n\n- **Cold Start Solutions**: Load `references\u002Fcold-start-strategies.md` for new user\u002Fitem strategies (popularity-based, onboarding, demographic, content-based bootstrapping, active learning), explore-exploit approaches (ε-greedy, Thompson sampling), and hybrid fallback chains\n",{"name":5,"license":15,"metadata":24,"description":7},{"keywords":25},"recommendation engine, collaborative filtering, matrix factorization, SVD, ALS, NMF, user-based CF, item-based CF, cold start, precision@k, recall@k, NDCG, hybrid recommender, content-based filtering, cosine similarity, implicit feedback, evaluation metrics, diversity, coverage","main","c475fc64e94e803b50d14a791dfee8853fbb2c5c","integrations\u002Fclaude-skills-secondsky\u002Fplugins\u002Frecommendation-engine\u002Fskills\u002Frecommendation-engine","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory","https:\u002F\u002Fgithub.com\u002FElogic360","2026-11-08 22:21:22",{"source":8,"skillName":5,"commands":33,"prompt":43,"zipAvailable":44},[34,37,40],{"tool":35,"command":36},"npx","npx skills add Elogic360\u002Fsoftware-factory --skill recommendation-engine",{"tool":38,"command":39},"bunx","bunx skills add Elogic360\u002Fsoftware-factory --skill recommendation-engine",{"tool":41,"command":42},"pnpm","pnpm dlx skills add Elogic360\u002Fsoftware-factory --skill recommendation-engine","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fintegrations\u002Fclaude-skills-secondsky\u002Fplugins\u002Frecommendation-engine\u002Fskills\u002Frecommendation-engine\u002FSKILL.md",true,[46,52,56,60],{"path":47,"resourceType":48,"resourceTypeDesc":49,"sizeBytes":50,"sourceHtmlUrl":51},"references\u002Fcold-start-strategies.md","REFERENCE","参考文档",19447,"https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fintegrations\u002Fclaude-skills-secondsky\u002Fplugins\u002Frecommendation-engine\u002Fskills\u002Frecommendation-engine\u002Freferences\u002Fcold-start-strategies.md",{"path":53,"resourceType":48,"resourceTypeDesc":49,"sizeBytes":54,"sourceHtmlUrl":55},"references\u002Fcollaborative-filtering-deep-dive.md",15768,"https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fintegrations\u002Fclaude-skills-secondsky\u002Fplugins\u002Frecommendation-engine\u002Fskills\u002Frecommendation-engine\u002Freferences\u002Fcollaborative-filtering-deep-dive.md",{"path":57,"resourceType":48,"resourceTypeDesc":49,"sizeBytes":58,"sourceHtmlUrl":59},"references\u002Fevaluation-metrics-implementation.md",17391,"https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fintegrations\u002Fclaude-skills-secondsky\u002Fplugins\u002Frecommendation-engine\u002Fskills\u002Frecommendation-engine\u002Freferences\u002Fevaluation-metrics-implementation.md",{"path":61,"resourceType":48,"resourceTypeDesc":49,"sizeBytes":62,"sourceHtmlUrl":63},"references\u002Fmatrix-factorization-methods.md",17731,"https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fintegrations\u002Fclaude-skills-secondsky\u002Fplugins\u002Frecommendation-engine\u002Fskills\u002Frecommendation-engine\u002Freferences\u002Fmatrix-factorization-methods.md",[65,73,80,87,94,101],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":69,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":19},"01M79G206MT3J6S0GY3C45P2KV","vss-summarize-video","Use to summarize a recorded video via the LVS summarization microservice (HITL-gated) with a VLM fallback. Not for report generation or live RTSP captioning.","Apache-2.0","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fskills\u002Fnvidia\u002Fvss-summarize-video\u002FSKILL.md",[],[],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":69,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":19},"01M79G1WN63PGRE8CKD47WEBQ5","vss-setup-video-analytics-api","Use to deploy the vss-video-analytics-api REST service standalone (config-source, data-log bind, Elasticsearch, optional Kafka). Not for full warehouse deploy.","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fskills\u002Fnvidia\u002Fvss-setup-video-analytics-api\u002FSKILL.md",[],[],{"skillNo":81,"name":82,"nameZh":6,"description":83,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":69,"licenseFileUrl":6,"sourceHtmlUrl":84,"categories":85,"keywords":86,"publishedAt":19},"01M79G1S9F7VY3EF6H53PRP5AN","vss-setup-behavior-analytics","Use to deploy the vss-behavior-analytics service standalone (entrypoint, config-source, optional calibration). Not for the full warehouse deploy.","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fskills\u002Fnvidia\u002Fvss-setup-behavior-analytics\u002FSKILL.md",[],[],{"skillNo":88,"name":89,"nameZh":6,"description":90,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":69,"licenseFileUrl":6,"sourceHtmlUrl":91,"categories":92,"keywords":93,"publishedAt":19},"01M79G1N1S1Y27PFZPYMNK1MTQ","vss-search-archive","Use this skill to run top-level VSS fusion search on archived video, or to ingest video files \u002F RTSP streams for search. Do NOT use for ad-hoc visual Q&A (use vss-ask-video), live captioning (use vss-deploy-dense-captioning), or video summarization and reports (use vss-summarize-video).","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fskills\u002Fnvidia\u002Fvss-search-archive\u002FSKILL.md",[],[],{"skillNo":95,"name":96,"nameZh":6,"description":97,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":69,"licenseFileUrl":6,"sourceHtmlUrl":98,"categories":99,"keywords":100,"publishedAt":19},"01M79G1H6WN0Q6C0VCAXCZX6B7","vss-query-analytics","Use this skill when reading video-analytics metrics, incidents, alerts, and sensor data via the VA-MCP server (port 9901). Not for live VLM or incident-range narrative reports.","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fskills\u002Fnvidia\u002Fvss-query-analytics\u002FSKILL.md",[],[],{"skillNo":102,"name":103,"nameZh":6,"description":104,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":69,"licenseFileUrl":6,"sourceHtmlUrl":105,"categories":106,"keywords":107,"publishedAt":19},"01M79G1DYPNXQS7QHZ0AAF5FX5","vss-manage-video-io-storage","Use to call the VIOS REST API (sensor list, timelines, clip extraction, snapshots, add\u002Fdelete sensors and streams). Not for VLM inference or search.","https:\u002F\u002Fgithub.com\u002FElogic360\u002Fsoftware-factory\u002Fblob\u002Fmain\u002Fskills\u002Fnvidia\u002Fvss-manage-video-io-storage\u002FSKILL.md",[],[]]