Développer un système de recommandation avec Python

1. Introduction : L’Indispensable Personnalisation en 2026

Dans le paysage numérique de 2026, la personnalisation n’est plus un simple avantage concurrentiel, mais une attente fondamentale des utilisateurs. Des géants du commerce électronique aux plateformes de streaming vidéo, en passant par les réseaux sociaux et les applications de productivité, les systèmes de recommandation sont devenus le moteur invisible qui façonne notre expérience en ligne. Ils nous aident à découvrir de nouveaux produits, films, musiques, articles ou même des contacts professionnels pertinents, transformant un océan d’informations en une sélection curatée et pertinente.

L’efficacité de ces systèmes est directement liée à leur capacité à comprendre les préférences individuelles et à anticiper les besoins. En 2026, avec l’explosion des données et l’amélioration continue des algorithmes d’intelligence artificielle et de machine learning, construire un système de recommandation performant est plus accessible que jamais, même pour les développeurs et les entreprises de taille moyenne. Python, avec son écosystème riche et mature de bibliothèques comme Scikit-learn, offre une boîte à outils robuste pour aborder ce défi.

Cet article vous guidera à travers les principes fondamentaux et les étapes pratiques pour construire votre propre système de recommandation. Nous démystifierons le jargon technique, explorerons les différentes approches algorithmiques et fournirons des exemples de code concrets utilisant Python et Scikit-learn. Que vous soyez un data scientist expérimenté ou un développeur curieux d’explorer le monde de l’IA, ce guide est conçu pour vous donner les clés de la personnalisation en 2026.

2. Fondements des Systèmes de Recommandation

Avant de plonger dans le code, il est essentiel de comprendre les différentes philosophies derrière les systèmes de recommandation. Il existe principalement trois catégories, chacune avec ses forces et ses faiblesses.

2.1. Filtrage Basé sur le Contenu (Content-Based Filtering)

Cette approche recommande des articles similaires à ceux qu’un utilisateur a aimés ou consommés par le passé. Elle se base sur les attributs descriptifs des articles et les préférences explicites ou implicites de l’utilisateur.

Caractéristiques Clés du Basé sur le Contenu

Indépendance — Ne nécessite pas de données sur d’autres utilisateurs, ce qui est utile pour les « cold start » d’utilisateurs.

Transparence — Facilement explicable (« Nous vous recommandons ce film car il est similaire à ‘Interstellar’ que vous avez aimé, tous deux étant des films de science-fiction avec des thèmes complexes »).

Surcharge de Spécialisation — Peut recommander des articles trop similaires, limitant la découverte de nouveaux horizons pour l’utilisateur.

Exemple : Si un utilisateur regarde beaucoup de films de science-fiction et d’action, le système analysera les genres, acteurs, réalisateurs, mots-clés de ces films et recommandera d’autres films partageant ces caractéristiques.

2.2. Filtrage Collaboratif (Collaborative Filtering)

Cette méthode se base sur les interactions passées entre les utilisateurs et les articles pour faire des recommandations. L’idée est que les utilisateurs ayant des goûts similaires interagiront de manière similaire avec les articles. Il existe deux sous-catégories principales :

Filtrage collaboratif basé sur l’utilisateur (User-Based) : Recommande des articles qu’ont aimés les utilisateurs « similaires ». Par exemple, « Les personnes qui ont aimé les mêmes films que vous ont aussi aimé ce film ».

Filtrage collaboratif basé sur l’article (Item-Based) : Recommande des articles similaires à ceux qu’un utilisateur a déjà aimés, mais la similarité est calculée entre les articles en fonction des utilisateurs qui les ont consommés. Par exemple, « Les personnes qui ont aimé ce film ont aussi aimé celui-ci ».

Avantages et Inconvénients du Collaboratif

Découverte — Peut recommander des articles inattendus qui ne sont pas directement liés aux attributs d’un article, mais qui sont populaires auprès de groupes de goût similaires.

« Cold Start » pour les nouveaux articles/utilisateurs — Difficile de recommander pour un nouvel article ou un nouvel utilisateur car il manque d’interactions.

Scalabilité — Peut être coûteux en calcul avec un grand nombre d’utilisateurs et d’articles, nécessitant des techniques de réduction de dimensionnalité comme la factorisation matricielle.

2.3. Systèmes Hybrides

Les systèmes hybrides combinent les approches basées sur le contenu et le filtrage collaboratif pour tirer parti des forces de chacun et atténuer leurs faiblesses. C’est l’approche la plus courante et la plus performante dans les systèmes de recommandation modernes en 2026.

POINT CLÉ

La sélection de l’approche dépend fortement de la nature de vos données (disponibilité des attributs d’articles, volume d’interactions utilisateur) et des défis spécifiques (cold start, scalabilité).

3. Préparation des Données : La Clé d’une Recommandation Efficace

La qualité et la structure de vos données sont primordiales pour la performance de votre système de recommandation. Une bonne préparation peut faire la différence entre un système qui devine et un système qui anticipe réellement.

3.1. Collecte et Structuration des Données

Les systèmes de recommandation nécessitent deux types de données principales :

• Données d’interactions utilisateur-article : Ce sont les informations sur la façon dont les utilisateurs interagissent avec les articles. Elles peuvent être explicites (notes, likes, avis) ou implicites (vues, clics, temps passé sur une page, achats). Pour un film, cela pourrait être l’ID de l’utilisateur, l’ID du film et la note attribuée.
• Données d’attributs d’articles : Ce sont les caractéristiques descriptives des articles. Pour un film, cela inclurait le titre, les genres, le synopsis, les acteurs, le réalisateur, l’année de sortie, etc.

Ces données sont généralement stockées dans des bases de données relationnelles, NoSQL ou des entrepôts de données. Pour l’analyse et la modélisation, elles sont souvent transformées en DataFrames Pandas en Python.

3.2. Représentation des Données : Matrices Utilisateur-Article

Pour le filtrage collaboratif, les données d’interactions sont souvent représentées sous forme de matrice utilisateur-article, où chaque ligne représente un utilisateur, chaque colonne un article, et les cellules contiennent l’interaction (par exemple, la note). Cette matrice est généralement très creuse (beaucoup de zéros ou de valeurs manquantes) car un utilisateur n’interagit qu’avec une petite fraction des articles disponibles.

Exemple de matrice utilisateur-article (notes de 1 à 5) :

    Film A  Film B  Film C  Film D
U1    5       -       3       -
U2    -       4       -       5
U3    1       -       -       2

Le symbole « – » représente une absence d’interaction ou de note.

3.3. Gestion des Valeurs Manquantes et du Problème du « Cold Start »

Le problème du « cold start » (démarrage à froid) survient lorsque de nouveaux utilisateurs ou de nouveaux articles sont ajoutés au système et qu’il y a peu ou pas de données d’interaction disponibles pour eux. Sans ces données, il est difficile de faire des recommandations pertinentes.

4. Approche Basée sur le Contenu avec Scikit-learn

L’approche basée sur le contenu est souvent le point de départ en raison de sa simplicité et de sa capacité à gérer le cold start des utilisateurs. Scikit-learn est parfaitement adapté pour construire les vecteurs de caractéristiques des articles et calculer leur similarité.

4.1. Vectorisation des Attributs Textuels

Pour des attributs textuels comme les genres, les synopsis ou les descriptions, nous devons les convertir en une représentation numérique que les algorithmes peuvent comprendre. La méthode TF-IDF (Term Frequency-Inverse Document Frequency) est un excellent choix.

Le TF-IDF attribue un poids à chaque mot en fonction de sa fréquence dans un document (TF) et de sa rareté dans l’ensemble des documents (IDF). Un mot fréquent dans un document mais rare dans la collection aura un poids élevé, indiquant qu’il est pertinent pour décrire ce document.

EXPLICATION DU CODE

Cet exemple utilise TfidfVectorizer de Scikit-learn pour transformer une liste de descriptions d’articles en une matrice TF-IDF. Nous utilisons ensuite cosine_similarity pour calculer la similarité entre ces vecteurs, ce qui nous donne une matrice de similarité entre articles.

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Exemple de données d'articles (films)
data = {
    'id': [1, 2, 3, 4],
    'titre': ['Interstellar', 'Blade Runner 2049', 'Dune', 'Le Seigneur des Anneaux'],
    'description': [
        'Un groupe d\'explorateurs spatiaux voyage à travers un trou de ver.',
        'Un jeune blade runner découvre un secret enfoui qui pourrait plonger ce qu\'il reste de la société dans le chaos.',
        'Un jeune homme doit se rendre sur une planète dangereuse pour assurer l\'avenir de son peuple.',
        'Un hobbit hérite d\'un anneau magique et entreprend un voyage épique pour le détruire.'
    ],
    'genres': [
        'Science-fiction, Aventure, Drame',
        'Science-fiction, Thriller, Drame',
        'Science-fiction, Aventure, Drame',
        'Fantaisie, Aventure'
    ]
}
movies_df = pd.DataFrame(data)

# Concaténer les attributs textuels pour la vectorisation
movies_df['combined_features'] = movies_df['description'] + ' ' + movies_df['genres']

# Initialiser le TfidfVectorizer
tfidf_vectorizer = TfidfVectorizer(stop_words='french')

# Appliquer le vectoriseur sur les caractéristiques combinées
tfidf_matrix = tfidf_vectorizer.fit_transform(movies_df['combined_features'])

# Calculer la similarité cosinus entre les films
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)

print("Matrice TF-IDF (extraits) :")
print(tfidf_matrix.shape) # (nombre_films, nombre_mots_uniques)
print("\nMatrice de similarité cosinus :")
print(cosine_sim)

# Fonction simple de recommandation basée sur la similarité
def get_recommendations_content_based(title, cosine_sim_matrix, df):
    # Obtenir l'index du film qui correspond au titre
    idx = df[df['titre'] == title].index[0]

    # Obtenir les scores de similarité de tous les films avec ce film
    sim_scores = list(enumerate(cosine_sim_matrix[idx]))

    # Trier les films en fonction des scores de similarité
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)

    # Obtenir les scores des 5 films les plus similaires (hors lui-même)
    sim_scores = sim_scores[1:6]

    # Obtenir les index des films
    movie_indices = [i[0] for i in sim_scores]

    # Retourner les titres des films les plus similaires
    return df['titre'].iloc[movie_indices]

print(f"\nRecommandations pour 'Interstellar' en {2026} :")
print(get_recommendations_content_based('Interstellar', cosine_sim, movies_df))

Le résultat de cosine_sim est une matrice où cosine_sim[i][j] représente la similarité entre le film i et le film j. Une valeur proche de 1 indique une forte similarité, tandis qu’une valeur proche de 0 indique une faible similarité.

POINT CLÉ

La vectorisation des textes avec TF-IDF est une étape fondamentale. Elle convertit le langage naturel en une forme numérique compréhensible par les algorithmes, permettant ensuite le calcul de similarité entre les articles.

5. Filtrage Collaboratif : Explorer les Similarités Utilisateur-Article

Le filtrage collaboratif est puissant pour découvrir des relations complexes entre utilisateurs et articles. Bien que Scikit-learn n’ait pas de modules dédiés à la factorisation matricielle (courante pour le collaboratif à grande échelle), il fournit des outils pour les calculs de similarité nécessaires aux approches basées sur les voisins (K-Nearest Neighbors).

5.1. Construction de la Matrice Utilisateur-Article

La première étape est de transformer vos données d’interactions en une matrice utilisateur-article. Chaque ligne représente un utilisateur, chaque colonne un article, et les valeurs sont les notes ou interactions. Les valeurs manquantes (où l’utilisateur n’a pas interagi avec l’article) sont généralement remplies par 0 ou NaN.

EXPLICATION DU CODE

Ce code simule la création d’une matrice utilisateur-article à partir de données de notes de films. Il utilise ensuite pairwise_distances pour calculer la similarité cosinus entre les utilisateurs. Une fois la similarité utilisateur calculée, on peut l’utiliser pour prédire les notes d’un utilisateur cible en se basant sur les notes de ses voisins les plus proches.

import pandas as pd
import numpy as np
from sklearn.metrics.pairwise import pairwise_distances

# Données de notes simulées (utilisateur, film, note)
ratings_data = {
    'user_id': [1, 1, 1, 2, 2, 3, 3, 3, 4, 4],
    'movie_id': [101, 102, 104, 101, 103, 102, 103, 104, 101, 102],
    'rating': [5, 3, 4, 4, 5, 2, 3, 4, 5, 4]
}
ratings_df = pd.DataFrame(ratings_data)

# Créer la matrice utilisateur-article
user_movie_matrix = ratings_df.pivot_table(index='user_id', columns='movie_id', values='rating').fillna(0)
print("Matrice Utilisateur-Article :")
print(user_movie_matrix)

# Calculer la similarité entre utilisateurs (basée sur la cosinus)
# On utilise 1 - similarité car pairwise_distances calcule la distance, pas la similarité
user_similarity = 1 - pairwise_distances(user_movie_matrix, metric='cosine')
user_similarity_df = pd.DataFrame(user_similarity, index=user_movie_matrix.index, columns=user_movie_matrix.index)
print("\nMatrice de Similarité Utilisateur :")
print(user_similarity_df)

# Fonction de prédiction simple (filtrage collaboratif basé sur l'utilisateur)
def predict_rating_user_based(user_id, movie_id, user_movie_matrix, user_similarity_df, k=3):
    if movie_id not in user_movie_matrix.columns:
        return np.nan # Film inconnu

    user_ratings = user_movie_matrix.loc[user_id]
    
    # Trouver les utilisateurs qui ont noté le film cible
    rated_by_users = user_movie_matrix[user_movie_matrix[movie_id] > 0].index
    
    if user_id not in rated_by_users: # Si l'utilisateur cible n'a pas encore noté le film
        # Obtenir les similarités de l'utilisateur cible avec tous les autres utilisateurs
        similarities = user_similarity_df.loc[user_id].drop(user_id)
        
        # Filtrer pour les utilisateurs qui ont noté le film et trier par similarité
        relevant_similarities = similarities[similarities.index.isin(rated_by_users)].sort_values(ascending=False)
        
        # Sélectionner les k voisins les plus proches
        top_k_neighbors = relevant_similarities.head(k)
        
        if top_k_neighbors.empty:
            return np.nan # Pas de voisins pertinents

        # Calculer la moyenne pondérée des notes des voisins
        # Notes des voisins pour le film cible
        neighbor_ratings = user_movie_matrix.loc[top_k_neighbors.index, movie_id]
        
        # Calcul de la prédiction
        predicted_rating = (neighbor_ratings * top_k_neighbors).sum() / top_k_neighbors.sum()
        return predicted_rating
    else:
        return user_ratings[movie_id] # L'utilisateur a déjà noté ce film

# Exemple de prédiction pour l'utilisateur 1 sur le film 103 (qu'il n'a pas noté)
user_to_predict = 1
movie_to_predict = 103
predicted_rating = predict_rating_user_based(user_to_predict, movie_to_predict, user_movie_matrix, user_similarity_df)
print(f"\nPrédiction de note pour l'utilisateur {user_to_predict} sur le film {movie_to_predict} : {predicted_rating:.2f}")

# Exemple de prédiction pour l'utilisateur 4 sur le film 103 (qu'il n'a pas noté)
user_to_predict_2 = 4
movie_to_predict_2 = 103
predicted_rating_2 = predict_rating_user_based(user_to_predict_2, movie_to_predict_2, user_movie_matrix, user_similarity_df)
print(f"Prédiction de note pour l'utilisateur {user_to_predict_2} sur le film {movie_to_predict_2} : {predicted_rating_2:.2f}")

Ce code illustre comment calculer les similarités entre utilisateurs. Pour les systèmes de recommandation réels, des bibliothèques dédiées comme Surprise → ou des approches de factorisation matricielle (par exemple, avec LightFM ou implicit) seraient préférables pour leur efficacité et leur capacité à gérer la sparsité.

POINT CLÉ

Le filtrage collaboratif, bien que puissant pour la découverte, est plus sensible à la sparsité des données et au problème du « cold start ». Les implémentations à grande échelle nécessitent souvent des techniques de factorisation matricielle ou des algorithmes basés sur les voisins optimisés.

6. Évaluation et Optimisation des Performances

Un système de recommandation n’est utile que s’il est performant. L’évaluation est cruciale pour comprendre l’efficacité de vos algorithmes et pour les optimiser. Les métriques varient selon que vous traitez des notes explicites ou des interactions implicites (recommandations top-N).

6.1. Métriques d’Évaluation

• Pour les notes explicites (prédiction de score) :
  • RMSE (Root Mean Squared Error) : Mesure la moyenne quadratique des erreurs entre les notes prédites et les notes réelles. Une RMSE plus faible indique une meilleure précision.
  • MAE (Mean Absolute Error) : Similaire à la RMSE, mais mesure la moyenne des valeurs absolues des erreurs. Moins sensible aux valeurs aberrantes que la RMSE.
• Pour les recommandations Top-N (classement) :
  • Précision (Precision@K) : Proportion des articles pertinents parmi les K premiers articles recommandés.
  • Rappel (Recall@K) : Proportion des articles pertinents qui ont été recommandés parmi tous les articles pertinents disponibles.
  • F1-score@K : Moyenne harmonique de la précision et du rappel.
  • MAP (Mean Average Precision) : Moyenne des précisions moyennes pour chaque requête, utile pour évaluer la qualité du classement sur plusieurs requêtes.

6.2. Validation Croisée et Hyperparamétrage

Pour obtenir des estimations fiables de la performance, la validation croisée est essentielle. Elle permet de s’assurer que le modèle généralise bien à de nouvelles données et n’est pas surajusté aux données d’entraînement.

L’hyperparamétrage consiste à ajuster les paramètres du modèle (par exemple, le nombre de voisins k dans un algorithme k-NN, ou le nombre de facteurs latents dans une factorisation matricielle) pour optimiser les métriques de performance. Des techniques comme GridSearchCV ou RandomizedSearchCV de Scikit-learn peuvent être utilisées, bien que pour les systèmes de recommandation complexes, des bibliothèques plus spécifiques ou l’optimisation bayésienne soient souvent préférées.

POINT CLÉ

Ne vous fiez pas uniquement aux métriques offline. Les tests A/B en production sont le moyen le plus fiable d’évaluer l’impact réel d’un système de recommandation sur l’engagement utilisateur et les objectifs commerciaux (par exemple, augmentation des ventes, temps passé sur la plateforme).

7. Cas d’Usage Avancés et Défis Éthiques en 2026

En 2026, les systèmes de recommandation ne se limitent plus aux algorithmes de base. Des approches plus sophistiquées émergent, mais elles s’accompagnent de défis complexes, notamment sur le plan éthique.

7.1. Recommandation Séquentielle et Contextuelle

Les modèles traditionnels traitent souvent les interactions comme des événements indépendants. Cependant, l’ordre des interactions et le contexte (heure, lieu, appareil, humeur de l’utilisateur) sont cruciaux.

• Recommandation Séquentielle : Utilise des architectures de deep learning comme les RNN (Recurrent Neural Networks), GRU (Gated Recurrent Units) ou les Transformers pour comprendre les préférences évolutives d’un utilisateur au fil du temps. Par exemple, une série de vidéos regardées sur YouTube ou une séquence d’achats sur un site de e-commerce.
• Recommandation Contextuelle : Intègre des informations contextuelles (par exemple, « recommander un restaurant pour le dîner un vendredi soir avec des amis ») pour affiner les recommandations. Ces modèles peuvent être construits en augmentant les données d’entrée avec des caractéristiques contextuelles ou en utilisant des modèles spécifiques comme les factorisations tensorielles.

7.2. Éthique et Biais dans les Systèmes de Recommandation

Avec la puissance de la personnalisation vient la responsabilité. Les systèmes de recommandation peuvent involontairement perpétuer ou amplifier des biais existants dans les données d’entraînement, menant à des résultats injustes ou à une « bulle de filtre ».

Les développeurs en 2026 doivent activement travailler à l’équité des recommandations en :

• Débiaisant les données : Identifier et corriger les biais dans les ensembles de données.
• Intégrant la diversité : Concevoir des métriques qui récompensent non seulement la pertinence mais aussi la diversité et la nouveauté des recommandations.
• Offrant de la transparence et du contrôle : Permettre aux utilisateurs de comprendre pourquoi un article leur est recommandé et de modifier leurs préférences.

8. Application Pratique : Un Recommandeur de Films Simple

Pour solidifier votre compréhension, nous allons construire un petit système de recommandation de films basé sur le contenu. Nous utiliserons un ensemble de données simulé pour illustrer le processus complet.

8.1. Étape 1 : Préparation des Données

Nous allons créer un DataFrame Pandas avec des informations sur quelques films.

EXPLICATION DU CODE

Ce bloc initialise un DataFrame avec des données de films, incluant des titres, des genres et des descriptions. Ces informations textuelles seront combinées pour former une base de caractéristiques pour notre système de recommandation.

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# 1. Préparation des données
movies_data = {
    'movie_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'title': [
        'Interstellar', 'Blade Runner 2049', 'Dune', 'Le Seigneur des Anneaux: La Communauté de l\'Anneau',
        'Inception', 'Matrix', 'Star Wars: Un nouvel espoir', 'Arrival',
        'Parasite', 'Whiplash'
    ],
    'genres': [
        'Science-Fiction, Aventure, Drame', 'Science-Fiction, Thriller, Drame', 'Science-Fiction, Aventure, Drame',
        'Fantaisie, Aventure, Drame', 'Science-Fiction, Action, Thriller', 'Science-Fiction, Action',
        'Science-Fiction, Aventure, Fantaisie', 'Science-Fiction, Drame, Mystère',
        'Thriller, Drame, Comédie', 'Drame, Musique'
    ],
    'description': [
        'Un groupe d\'explorateurs spatiaux voyage à travers un trou de ver pour assurer la survie de l\'humanité.',
        'Un jeune blade runner découvre un secret enfoui qui pourrait plonger ce qu\'il reste de la société dans le chaos.',
        'Un jeune homme doit se rendre sur une planète dangereuse pour assurer l\'avenir de son peuple.',
        'Un hobbit hérite d\'un anneau magique et entreprend un voyage épique pour le détruire.',
        'Un voleur habile qui vole des informations en s\'introduisant dans les rêves des gens.',
        'Un programmeur découvre que le monde est une simulation et se bat contre les machines.',
        'Un jeune fermier se joint à une quête pour sauver une princesse et détruire une station spatiale.',
        'Une linguiste est recrutée pour communiquer avec des extraterrestres arrivés sur Terre.',
        'Une famille pauvre s\'infiltre dans la vie d\'une famille riche, avec des conséquences inattendues.',
        'Un jeune batteur de jazz s\'entraîne avec un professeur impitoyable.'
    ]
}
movies_df = pd.DataFrame(movies_data)

# Combiner les caractéristiques textuelles en une seule colonne
movies_df['combined_features'] = movies_df['genres'] + ' ' + movies_df['description']

print("Aperçu des données des films :")
print(movies_df.head())
print("\n")

8.2. Étape 2 : Vectorisation des Caractéristiques

Nous utiliserons TfidfVectorizer pour convertir la colonne combined_features en une matrice numérique.

EXPLICATION DU CODE

Ici, TfidfVectorizer est appliqué à la colonne des caractéristiques combinées. Il va créer un vocabulaire de tous les mots uniques et transformer chaque document (film) en un vecteur numérique où chaque dimension correspond à un mot et sa valeur est son score TF-IDF.

# 2. Vectorisation des caractéristiques
tfidf_vectorizer = TfidfVectorizer(stop_words='french') # Ignorer les mots courants en français
tfidf_matrix = tfidf_vectorizer.fit_transform(movies_df['combined_features'])

print("Forme de la matrice TF-IDF :", tfidf_matrix.shape)
print("\n")

8.3. Étape 3 : Calcul de Similarité

Nous calculerons la similarité cosinus entre tous les films à l’aide de la matrice TF-IDF.

EXPLICATION DU CODE

La fonction cosine_similarity prend la matrice TF-IDF et retourne une matrice carrée où chaque cellule (i, j) contient la similarité cosinus entre le film i et le film j. Les valeurs vont de 0 (pas similaire) à 1 (identique).

# 3. Calcul de similarité
cosine_sim_matrix = cosine_similarity(tfidf_matrix, tfidf_matrix)

print("Matrice de similarité cosinus (premières lignes) :")
print(cosine_sim_matrix[:5, :5]) # Affiche les 5 premières lignes et colonnes
print("\n")

8.4. Étape 4 : Fonction de Recommandation

Enfin, nous créerons une fonction qui prend un titre de film et retourne les films les plus similaires.

EXPLICATION DU CODE

Cette fonction recherche le film d’entrée, trouve son index, puis utilise la matrice de similarité pour identifier les films les plus proches. Elle trie les films par score de similarité et renvoie les N premiers, excluant le film d’origine lui-même.

# 4. Fonction de recommandation
def get_movie_recommendations(title, cosine_sim_matrix, df, num_recommendations=5):
    # Obtenir l'index du film qui correspond au titre
    if title not in df['title'].values:
        print(f"Le film '{title}' n'est pas trouvé dans la base de données.")
        return pd.Series([])
    
    idx = df[df['title'] == title].index[0]

    # Obtenir les scores de similarité de tous les films avec ce film
    sim_scores = list(enumerate(cosine_sim_matrix[idx]))

    # Trier les films en fonction des scores de similarité
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)

    # Obtenir les scores des 'num_recommendations' films les plus similaires (hors lui-même)
    sim_scores = sim_scores[1:num_recommendations+1]

    # Obtenir les index des films
    movie_indices = [i[0] for i in sim_scores]

    # Retourner les titres des films les plus similaires
    return df['title'].iloc[movie_indices]

# Exemple d'utilisation du recommandeur
print(f"Recommandations pour 'Dune' en {2026} :")
print(get_movie_recommendations('Dune', cosine_sim_matrix, movies_df))
print("\n")

print(f"Recommandations pour 'Parasite' en {2026} :")
print(get_movie_recommendations('Parasite', cosine_sim_matrix, movies_df))
print("\n")

print(f"Recommandations pour 'Matrix' en {2026} :")
print(get_movie_recommendations('Matrix', cosine_sim_matrix, movies_df))
print("\n")

Ce système de recommandation, bien que simple, illustre les principes de base du filtrage basé sur le contenu. Pour un système de production en 2026, vous devriez le combiner avec d’autres approches (hybride), gérer des ensembles de données beaucoup plus importants et implémenter des mécanismes de mise à jour des modèles.

9. Comparaison des Approches et Scénarios d’Utilisation

Le choix de l’approche de recommandation dépend de plusieurs facteurs, notamment la nature de vos données, les ressources disponibles et les objectifs commerciaux. Voici un tableau comparatif pour vous aider à décider.

En 2026, la tendance est clairement aux systèmes hybrides, qui offrent le meilleur des deux mondes en termes de pertinence, de diversité et de gestion des défis comme le « cold start ». Pour un démarrage rapide ou des données limitées, le basé sur le contenu est souvent le plus simple à implémenter. Pour des plateformes avec beaucoup d’interactions utilisateur, le collaboratif est essentiel pour une découverte riche.

FAQ sur les Systèmes de Recommandation

Q. Qu’est-ce qu’un système de recommandation ?

Un système de recommandation est un algorithme qui suggère des articles (produits, films, musiques, etc.) à des utilisateurs en fonction de leurs préférences passées ou de celles d’utilisateurs similaires. Son objectif est d’améliorer l’expérience utilisateur et d’augmenter l’engagement ou les ventes.

Q. Pourquoi Python et Scikit-learn sont-ils recommandés pour les systèmes de recommandation ?

Python est un langage polyvalent avec un vaste écosystème de bibliothèques de science des données. Scikit-learn, en particulier, offre des outils robustes pour la vectorisation de texte (TF-IDF), le calcul de similarité (cosinus, euclidienne) et des algorithmes de clustering ou de classification qui sont des briques fondamentales pour les systèmes basés sur le contenu et les approches de filtrage collaboratif basées sur les voisins.

Q. Qu’est-ce que le problème du « cold start » et comment le résoudre ?

Le « cold start » se produit lorsqu’un nouveau film ou un nouvel utilisateur apparaît sans historique d’interactions, rendant les recommandations difficiles. Pour les nouveaux articles, on peut utiliser des recommandations basées sur les attributs du contenu ou la popularité globale. Pour les nouveaux utilisateurs, on peut demander des préférences initiales ou recommander des articles très populaires ou diversifiés.

Q. Quels sont les principaux types de systèmes de recommandation ?

Les trois types principaux sont : le filtrage basé sur le contenu (recommande des articles similaires à ceux aimés par l’utilisateur), le filtrage collaboratif (recommande des articles basés sur les préférences d’utilisateurs similaires ou la similarité entre articles via les interactions) et les systèmes hybrides (qui combinent les deux premiers pour tirer parti de leurs forces respectives).