Améliorer la Précision des Systèmes de Recommandation avec les LLM, en Utilisant Python

Augmenter la précision des systèmes de recommandation avec les LLM, en utilisant Python

Les moteurs de recommandation traditionnels ont longtemps reposé sur le filtrage collaboratif, la factorisation matricielle et les architectures d'apprentissage profond pour prédire les préférences des utilisateurs. Si ces méthodes excellent dans l'exploitation de grands ensembles de données comportementales, elles peinent souvent avec les éléments à démarrage à froid, les historiques d'interaction clairsemés et les nuances sémantiques enfouies dans les métadonnées non structurées telles que les descriptions de produits, les avis ou les résumés de contenu. Les grands modèles de langage (LLM) offrent un complément convaincant aux pipelines classiques. En encodant la compréhension du langage naturel, le raisonnement zero-shot et le scoring de pertinence contextuelle, les LLM peuvent combler le fossé entre le texte brut et l'intention de l'utilisateur.

La convergence de l'IA générative et de l'infrastructure de recommandation est un thème récurrent dans les principaux canaux industriels, notamment le [Google AI Blog](https://blog.google/technology/ai/), le [Microsoft AI Blog](https://www.microsoft.com/en-us/ai/blog/), [OpenAI News](https://openai.com/news/) et la communauté [Towards Data Science](https://towardsdatascience.com/). Plutôt que de remplacer les couches de recherche éprouvées, les praticiens adoptent de plus en plus des architectures hybrides : les modèles classiques génèrent un large ensemble de candidats, et les LLM affinent, réordonnent ou expliquent ces candidats pour augmenter la précision. Cet article fournit un guide pratique pour construire de tels workflows hybrides en Python, couvrant la configuration de l'environnement, l'enrichissement par embeddings et le réordonnancement piloté par LLM.

Prérequis

Avant de poursuivre, assurez-vous que votre poste de travail répond aux conditions préalables suivantes :

• **Python 3.9 ou plus récent** installé et disponible dans le chemin système.
• **pip**, l'installateur de paquets Python, mis à jour vers une version récente.
• **Outils d'environnement virtuel** (`venv` suffit) pour isoler les dépendances du projet.
• Une **clé API OpenAI** si vous envisagez d'exécuter les exemples de réordonnancement basés sur GPT. Vous pouvez en obtenir une sur la plateforme OpenAI.
• **Matériel** : Un minimum de 4 Go de RAM est suffisant pour les petits modèles d'embedding locaux. Si vous prévoyez d'expérimenter avec des LLM open source plus volumineux en local, 16 Go de RAM et un GPU moderne sont recommandés ; cependant, les exemples ci-dessous utilisent des modèles basés sur API ou des sentence transformers légers pour rester accessibles.

Installation étape par étape

Commencez par créer un répertoire dédié pour héberger vos fichiers de projet et votre code.

mkdir llm-recommender && cd llm-recommender

Créez un environnement virtuel Python nommé `venv` pour garder les dépendances isolées de votre installation Python globale.

python -m venv venv

Activez l'environnement virtuel. Sur Linux ou macOS, exécutez la commande suivante.

source venv/bin/activate

Sur Windows, utilisez le script d'activation analogue.

venv\Scripts\activate

Mettez à jour `pip` pour éviter les problèmes de compatibilité lors de l'installation des wheels de calcul scientifique.

pip install --upgrade pip

Installez les bibliothèques principales nécessaires à la manipulation de données, aux métriques de similarité traditionnelles, à l'inférence d'embedding locale et à l'accès à l'API OpenAI.

pip install pandas numpy scikit-learn sentence-transformers openai python-dotenv

Créez un fichier d'environnement caché nommé `.env` pour stocker vos identifiants API en toute sécurité, hors du contrôle de version.

touch .env

Ouvrez `.env` dans votre éditeur de texte et ajoutez votre clé API OpenAI comme indiqué ci-dessous. Remplacez l'espace réservé par votre clé réelle.

OPENAI_API_KEY=sk-your-key-here

Votre environnement est maintenant prêt. La pile installée vous permet d'exécuter des modèles d'embedding locaux sans GPU, d'interagir avec l'API d'OpenAI pour le travail générationnel lourd, et de gérer des données tabulaires avec `pandas`.

Exemples d'utilisation

Les sections suivantes démontrent trois façons distinctes d'injecter des capacités LLM dans un pipeline de recommandation. Chaque exemple est autonome et peut être adapté à vos propres données de catalogue.

Exemple 1 : Embeddings sémantiques d'éléments avec sentence transformers

Le filtrage collaboratif classique échoue lorsque de nouveaux éléments entrent dans le catalogue car il n'y a pas d'interactions utilisateur à partir desquelles apprendre. Une première étape robuste consiste à encoder les métadonnées des éléments — telles que les titres, descriptions ou tags — en vecteurs denses à l'aide d'un modèle transformer. En calculant la similarité entre les vecteurs de profil utilisateur et les vecteurs d'éléments, vous pouvez faire surface à du contenu sémantiquement pertinent même sans signaux historiques.

Le code ci-dessous charge un modèle léger, encode un catalogue jouet, et classe les éléments par rapport à une chaîne d'intérêt utilisateur.

import pandas as pd
import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# Charge un modèle d'embedding compact et de haute qualité, adapté à l'inférence CPU.
model = SentenceTransformer('all-MiniLM-L6-v2')

# Construit un catalogue jouet où chaque élément a un texte descriptif non structuré.
items = pd.DataFrame({
    'item_id': [1, 2, 3, 4],
    'description': [
        'Un thriller cyberpunk se déroulant dans un monde souterrain dystopique de Tokyo',
        'Un guide pratique sur l\'apprentissage automatique Python et pandas',
        'Une comédie romantique sur deux chefs pâtissiers rivaux à Paris',
        'Un manuel d'introduction à l'apprentissage profond et aux réseaux de neurones'
    ]
})

# Encode les descriptions du catalogue en vecteurs denses de 384 dimensions.
item_embeddings = model.encode(
    items['description'].tolist(),
    convert_to_numpy=True,
    show_progress_bar=False
)

# Simule un profil utilisateur exprimé en langage naturel.
user_query = "Je veux apprendre l'intelligence artificielle et les réseaux de neurones"

# Encode la requête utilisateur dans le même espace sémantique.
user_embedding = model.encode([user_query], convert_to_numpy=True)

# Calcule la similarité cosinus entre l'utilisateur et chaque élément.
similarity_scores = cosine_similarity(user_embedding, item_embeddings).flatten()

# Attache les scores et trie pour produire le classement final.
items['similarity'] = similarity_scores
ranked_items = items.sort_values('similarity', ascending=False)

print(ranked_items[['item_id', 'description', 'similarity']])

Dans ce modèle, les embeddings dérivés des LLM capturent des relations sémantiques que les seuls identifiants d'éléments ne peuvent pas. Un modèle de factorisation matricielle pourrait associer l'élément 2 et l'élément 4 uniquement si des utilisateurs ont cliqué dessus conjointement, tandis que le modèle d'embedding reconnaît leur similarité thématique immédiatement. En production, vous pouvez stocker ces vecteurs dans une base de données vectorielle.