IwanttolearnAI
Machine LearningAvancé24 min de lecture · 40 vues

Systèmes de Recommandation : de Netflix à Spotify

Découvrez comment Netflix, Spotify et Amazon construisent leurs moteurs de recommandation. De la factorisation matricielle aux two-tower models, maîtrisez les algorithmes et les métriques.

Par Alex Perey

Les systèmes de recommandation

80% des contenus regardés sur Netflix proviennent des recommandations. Ces systèmes sont parmi les applications ML les plus impactantes.

ApprochePrincipeExemple réel
CollaboratifUtilisateurs similaires → mêmes goûtsNetflix "ceux qui ont regardé X ont aimé Y"
Basé contenuItems similaires à ce qu'on a aiméSpotify : BPM, tonalité, énergie similaires
HybrideCombine les deuxAmazon : collaboratif + contenu + contexte

1. Collaborative Filtering : user-based vs item-based

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Matrice utilisateur-film (0 = pas vu, 1-5 = note)
ratings = np.array([
    [5, 4, 0, 0, 1],
    [4, 0, 0, 1, 2],
    [0, 0, 5, 4, 0],
    [0, 1, 4, 5, 0],
    [1, 0, 0, 0, 5],
])

# Similarité entre utilisateurs
user_sim = cosine_similarity(ratings)
print("Similarité User 0 vs tous :", user_sim[0].round(3))

L'item-based est souvent préféré en production : la matrice items est plus stable dans le temps (moins de nouveaux items que de nouveaux utilisateurs).

2. Matrix Factorization : facteurs latents

La matrice utilisateur-item est creuse (sparse) : un utilisateur typique note 0.1% des films. SVD décompose la matrice R en facteurs latents :

R ≈ U × Σ × Vᵀ
  • U : profils utilisateurs (goûts implicites)
  • Vᵀ : profils films (caractéristiques latentes)

Les facteurs capturent des concepts comme "films d'action des années 80" sans jamais les définir explicitement.

3. Micro-exercice : recommandation de films avec SVD

import numpy as np
from sklearn.decomposition import TruncatedSVD

ratings = np.array([
    [5, 4, 0, 0, 1],
    [4, 0, 0, 1, 2],
    [0, 0, 5, 4, 0],
    [0, 1, 4, 5, 0],
    [1, 0, 0, 0, 5],
], dtype=float)

# SVD avec k=2 facteurs latents
svd          = TruncatedSVD(n_components=2, random_state=42)
user_factors = svd.fit_transform(ratings)
item_factors = svd.components_.T

# Reconstruction complète : prédit les cases vides
predicted = user_factors @ item_factors.T

films = ["Inception", "La La Land", "The Revenant", "Interstellar", "Parasite"]
print("Scores prédits pour l'utilisateur 0 :")
for film, score in zip(films, predicted[0]):
    seen = "✓ déjà vu" if ratings[0, films.index(film)] > 0 else "→ à recommander"
    print(f"  {film:15s} : {score:.2f}  {seen}")

4. Content-based Filtering

import numpy as np

# Features de films (genre one-hot + durée normalisée)
item_features = np.array([
    [1, 0, 0, 1, 0.7],  # Action + Sci-Fi, long
    [0, 1, 0, 0, 0.4],  # Comédie, court
    [1, 0, 1, 0, 0.8],  # Action + Drame, long
])

user_ratings = np.array([5, 0, 4])  # 0 = pas vu
mask = user_ratings > 0
user_profile = np.average(item_features[mask], weights=user_ratings[mask], axis=0)

scores = item_features @ user_profile
print("Scores de recommandation :", scores.round(3))

5. Le Cold Start Problem

Le problème du démarrage à froid est l'un des défis majeurs en production.

TypeProblèmeSolutions
Nouvel utilisateurAucun historiqueOnboarding (sélection initiale), popularité
Nouvel itemAucune noteContent-based sur features, early adopters

6. Two-Tower Models : l'architecture industrielle

Les embeddings items sont précalculés une fois et indexés avec FAISS. Au moment de la requête, seul le user embedding est calculé → recherche ANN en millisecondes sur des millions d'items.

YouTube sert des recommandations en < 100ms sur un catalogue de 800 millions de vidéos grâce à cette architecture.

7. Métriques d'évaluation

def precision_at_k(recommended, relevant, k):
    hits = len(set(recommended[:k]) & set(relevant))
    return hits / k

def ndcg_at_k(recommended, relevant, k):
    import numpy as np
    dcg  = sum(1/np.log2(i+2) for i, item in enumerate(recommended[:k]) if item in relevant)
    idcg = sum(1/np.log2(i+2) for i in range(min(len(relevant), k)))
    return dcg / idcg if idcg > 0 else 0

recommended = ["Inception", "La La Land", "Interstellar", "Parasite", "Dune"]
relevant     = ["Inception", "Interstellar", "Blade Runner 2049"]

print(f"Precision@3 : {precision_at_k(recommended, relevant, 3):.2f}")
print(f"NDCG@5      : {ndcg_at_k(recommended, relevant, 5):.3f}")
MétriqueCe qu'elle mesure
Precision@KQualité des K résultats
Recall@KCouverture du catalogue pertinent
NDCG@KQualité + ordre des résultats
Hit RateAu moins 1 bon résultat dans @K

8. LLM as Recommender : tendance 2026

Les LLMs fine-tunés sur des historiques d'interactions dépassent les two-tower models sur les datasets cold-start (méta, Google, Baidu 2025).

Avantages : compréhension sémantique, zero-shot sur nouveaux items, explicabilité. Limites : coût d'inférence prohibitif à l'échelle, hallucinations, latence incompatible avec le temps réel.

Architecture hybride pragmatique : LLM pour l'encodage sémantique + two-tower pour le retrieval à grande échelle.

À propos de l'auteur

Alex Perey

Diplômé d'un master en intelligence artificielle, je travaille au quotidien sur des projets IA en entreprise. J'ai créé IwanttolearnAI pour rendre l'apprentissage de l'IA accessible à tous, gratuitement.

GitHub·En savoir plus

Retour à Machine Learning

Continuer à apprendre

Machine LearningIntermédiaire

Séries Temporelles et Prévision avec Python

Apprenez à modéliser et prévoir des séries temporelles avec ARIMA, Prophet et XGBoost. Maîtrisez la validation temporelle correcte et les métriques adaptées.

22 min de lecture · 61 vues

Machine LearningIntermédiaire

SVM, Arbres de Décision et Random Forest en Profondeur

Maîtrisez les algorithmes classiques les plus puissants du ML : SVM avec kernel trick, arbres de décision et Random Forest. Comprendre quand ces modèles battent le Deep Learning.

20 min de lecture · 35 vues