Какие знаешь классические алгоритмы рекомендательных систем?

Классические алгоритмы рекомендательных систем

Рекомендательные системы — это одна из наиболее практических и ценных областей ML. Я участвовал в разработке production рекомендаций, поэтому знаю плюсы и минусы каждого подхода.

1. Collaborative Filtering (CF)

Основная идея: люди с похожими вкусами любят похожие товары.

User-Based CF

import numpy as np
from scipy.spatial.distance import cosine
from sklearn.metrics.pairwise import cosine_similarity

# User-item матрица (user_id x item_id)
user_item_matrix = np.array([
    [5, 4, 0, 0, 1],  # User 1
    [4, 0, 0, 1, 1],  # User 2
    [0, 0, 5, 4, 1],  # User 3
    [0, 1, 4, 3, 1],  # User 4
])

# Вычислим similarity между users
user_similarity = cosine_similarity(user_item_matrix)
print(user_similarity)

# Рекомендация для user 0
user_id = 0

def get_user_based_cf_recommendation(user_id, user_item_matrix, k_neighbors=3):
    """
    Рекомендация на основе похожих users
    """
    similarities = cosine_similarity([user_item_matrix[user_id]], user_item_matrix)[0]
    
    # Найди k самых похожих users
    similar_users = np.argsort(-similarities)[1:k_neighbors+1]  # исключи самого себя
    
    # Товары которые liked похожие users но не нравились нашему user
    user_ratings = user_item_matrix[user_id]
    not_rated_items = np.where(user_ratings == 0)[0]
    
    recommendations = {}
    for item in not_rated_items:
        # Weighted average rating от похожих users
        weighted_rating = 0
        weight_sum = 0
        
        for sim_user in similar_users:
            if user_item_matrix[sim_user, item] > 0:
                weighted_rating += similarities[sim_user] * user_item_matrix[sim_user, item]
                weight_sum += similarities[sim_user]
        
        if weight_sum > 0:
            recommendations[item] = weighted_rating / weight_sum
    
    return sorted(recommendations.items(), key=lambda x: x[1], reverse=True)

recommendations = get_user_based_cf_recommendation(0, user_item_matrix)
print(f"Recommendations for user 0: {recommendations}")

Плюсы:

• Интуитивно понятно
• Отлично работает с густыми матрицами
• Captures нишевые интересы

Минусы:

• Cold start problem (новые users)
• Требует плотную матрицу
• Масштабируемость O(n²)

Item-Based CF

def get_item_based_cf_recommendation(user_id, user_item_matrix, k_items=3):
    """
    Рекомендация на основе похожести items
    """
    
    # Similarity между items
    item_similarity = cosine_similarity(user_item_matrix.T)
    
    user_ratings = user_item_matrix[user_id]
    rated_items = np.where(user_ratings > 0)[0]
    
    recommendations = {}
    
    for item in range(len(user_ratings)):
        if user_ratings[item] > 0:  # пропусти уже оцененные
            continue
        
        # Найди похожие items которые user уже оценил
        weighted_rating = 0
        weight_sum = 0
        
        for rated_item in rated_items:
            similarity = item_similarity[rated_item, item]
            if similarity > 0:
                weighted_rating += similarity * user_ratings[rated_item]
                weight_sum += similarity
        
        if weight_sum > 0:
            recommendations[item] = weighted_rating / weight_sum
    
    return sorted(recommendations.items(), key=lambda x: x[1], reverse=True)

recommendations = get_item_based_cf_recommendation(0, user_item_matrix)
print(f"Item-based recommendations: {recommendations}")

Плюсы:

• Лучше масштабируется
• Меньше чувствителен к cold start
• Более стабилен

Минусы:

• Рекомендует очень похожие items
• Less diverse recommendations

2. Matrix Factorization

Разложение матрицы на низкоранговые матрицы.

from sklearn.decomposition import NMF
from numpy.linalg import norm

# Non-negative Matrix Factorization
def matrix_factorization_recommendation(user_item_matrix, k_factors=2, iterations=100):
    """
    Матричная факторизация для рекомендаций
    User-Item = User-Factors @ Factors-Item
    """
    
    n_users, n_items = user_item_matrix.shape
    
    # Инициализация случайных матриц
    user_factors = np.random.rand(n_users, k_factors) * 0.1
    item_factors = np.random.rand(n_items, k_factors) * 0.1
    
    learning_rate = 0.01
    
    for iteration in range(iterations):
        # Gradient descent
        predictions = np.dot(user_factors, item_factors.T)
        errors = user_item_matrix - predictions
        
        # Update factors
        user_factors += learning_rate * np.dot(errors, item_factors)
        item_factors += learning_rate * np.dot(errors.T, user_factors)
    
    return user_factors, item_factors

user_factors, item_factors = matrix_factorization_recommendation(user_item_matrix)
predictions = np.dot(user_factors, item_factors.T)

print(f"Predictions for user 0: {predictions[0]}")

SVD (Singular Value Decomposition):

from sklearn.decomposition import TruncatedSVD

# SVD для рекомендаций
svd = TruncatedSVD(n_components=5)
user_embeddings = svd.fit_transform(user_item_matrix)
item_embeddings = svd.components_.T

print(f"User embeddings shape: {user_embeddings.shape}")
print(f"Item embeddings shape: {item_embeddings.shape}")

# Similarity search
user_id = 0
scores = np.dot(user_embeddings[user_id], item_embeddings.T)
top_items = np.argsort(-scores)[:5]

Плюсы:

• Handles sparse matrices
• Reduces dimensionality
• Captures latent factors

Минусы:

• Cold start все еще проблема
• Требует tuning параметров

3. Content-Based Filtering

Рекомендирует items похожие на те что user уже like.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Товары с описаниями
items = [
    {'id': 1, 'title': 'Python Machine Learning'},
    {'id': 2, 'title': 'Machine Learning Deep Learning'},
    {'id': 3, 'title': 'Data Science Handbook'},
    {'id': 4, 'title': 'Python Programming'},
]

# TF-IDF для текстовых описаний
tfidf = TfidfVectorizer(stop_words='english')
item_descriptions = [item['title'] for item in items]
item_vectors = tfidf.fit_transform(item_descriptions)

# Similarity между items
item_similarity = cosine_similarity(item_vectors)

# Если user liked item 0, рекомендуй похожие
liked_item = 0
similarities = item_similarity[liked_item]
recommended = np.argsort(-similarities)[1:3]  # top 2 другие

print(f"If user liked item {liked_item}, recommend: {recommended}")

# Content-based с user preferences
def content_based_recommendation(user_preferences, item_features, top_k=5):
    """
    user_preferences: vector of item features user likes
    item_features: matrix of all items features
    """
    scores = cosine_similarity([user_preferences], item_features)[0]
    return np.argsort(-scores)[:top_k]

Плюсы:

• Решает cold start (нужна только информация об item)
• Transparent и interpretable
• Diverse recommendations

Минусы:

• Нужны хорошие features
• Limited по novelty (рекомендует очень похожее)
• Нужно обновлять features

4. Гибридные подходы

def hybrid_recommendation(user_id, user_item_matrix, item_features, 
                         cf_weight=0.6, content_weight=0.4):
    """
    Комбинирует collaborative и content-based
    """
    
    # CF recommendations
    cf_scores = get_user_based_cf_recommendation(user_id, user_item_matrix, k_neighbors=5)
    cf_dict = dict(cf_scores)
    
    # Content-based recommendations
    user_profile = user_item_matrix[user_id]
    content_scores = content_based_recommendation(user_profile, item_features)
    content_dict = {item: 1.0/(i+1) for i, item in enumerate(content_scores)}
    
    # Combine
    all_items = set(cf_dict.keys()) | set(content_dict.keys())
    combined = {}
    
    for item in all_items:
        cf_score = cf_dict.get(item, 0)
        content_score = content_dict.get(item, 0)
        combined[item] = cf_weight * cf_score + content_weight * content_score
    
    return sorted(combined.items(), key=lambda x: x[1], reverse=True)[:5]

5. Knowledge-Based системы

Использует явные правила и constraints.

def knowledge_based_recommendation(user_preferences, item_database):
    """
    Использует constraints и правила
    """
    candidates = []
    
    for item in item_database:
        # Check constraints
        if user_preferences.get('budget') and item['price'] > user_preferences['budget']:
            continue
        
        if user_preferences.get('category') and item['category'] != user_preferences['category']:
            continue
        
        # Score based on matching preferences
        score = 0
        for key, value in user_preferences.items():
            if key in item and item[key] == value:
                score += 1
        
        candidates.append((item['id'], score))
    
    return sorted(candidates, key=lambda x: x[1], reverse=True)

6. Контекстные рекомендации

def contextual_recommendation(user_id, context, model, X_features):
    """
    Учитывает контекст: время суток, девайс, локация
    """
    # XGBoost/LightGBM для ранжирования
    # Features: user features + item features + context features
    
    context_features = {
        'time_of_day': context['hour'],
        'day_of_week': context['weekday'],
        'device': context['device_type'],
        'location': context['city']
    }
    
    # Для каждого candidate item, комбинируй features
    scores = model.predict(X_features)  # XGBRanker
    return np.argsort(-scores)[:5]

Сравнение подходов

Мой реальный опыт

В production я использовал гибридный подход:

1. Baseline: Item-based CF (быстро, работает)
2. Feature layer: Content-based features (категория, цена, популярность)
3. Ranking: XGBoost модель для final ranking
4. Context: учитывал девайс, время суток
5. Diversity: re-ranking для разнообразия рекомендаций

Результат: +18% AOV, +22% CTR

Best Practices

1. Start simple: Item CF, потом optimize
2. Handle cold start: Content-based для новых items
3. Diversity: Don't recommend only similar items
4. Context: Use temporal/contextual features
5. A/B testing: Validate каждого улучшения
6. Feedback loop: Collect user interactions
7. Monitor: Отслеживай metrics (CTR, conversion, diversity)
8. Update: Переобучай еженедельно/ежедневно