Recommender Systems (Content-based Filtering)

Système de recommandation basé sur le contenu utilisant des embeddings de phrases pour trouver des critiques de films similaires à partir d'une critique utilisateur.

Vue d'ensemble du projet

Ce projet implémente un système de recommandation basé sur le contenu pour analyser des critiques de films et trouver des critiques similaires. Le système utilise des embeddings de phrases générés par un modèle SentenceTransformer multilingue pour calculer la similarité cosinus entre les critiques.

L'application traite un dataset de critiques du film Fight Club, nettoie le texte en supprimant les caractères spéciaux et le HTML, puis génère des embeddings vectoriels pour chaque critique. L'utilisateur peut saisir sa propre critique et le système retourne les 5 critiques les plus similaires avec leurs scores de similarité.

Le projet démontre l'application pratique du NLP et des systèmes de recommandation dans le domaine du divertissement, en utilisant des techniques avancées de traitement du langage naturel et de calcul de similarité sémantique.

Fonctionnalités clés

🧠 Modèle SentenceTransformer multilingue - Utilisation de paraphrase-multilingual-MiniLM-L12-v2 pour générer des embeddings de haute qualité

📝 Nettoyage intelligent du texte - Suppression des balises HTML, normalisation des espaces et gestion des caractères spéciaux

🔍 Calcul de similarité cosinus - Comparaison vectorielle pour identifier les critiques les plus proches sémantiquement

🎯 Recommandations personnalisées - Retour des 5 critiques les plus similaires avec scores de confiance

⚡ Interface interactive - Saisie de critiques personnalisées avec boucle de recherche continue

📊 Filtrage par seuil - Possibilité de définir un seuil de similarité minimum pour les résultats

🔄 Traitement en temps réel - Génération d'embeddings et calcul de similarité instantanés

📈 Analyse de contenu - Focus sur l'analyse sémantique des critiques de films

Implémentation du code

1. Import des bibliothèques

from preper_f import PreperData
import pandas as pd
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
from bs4 import BeautifulSoup
import re

2. Chargement et prétraitement des données

def main():
    data = pd.read_csv('fightclub_critiques.csv', encoding="utf-8")
    preper_data = PreperData(data)
    preper_data.preper_data()
    
    # Nettoyage des caractères spéciaux
    preper_data.data["review_content"] = preper_data.data["review_content"].apply(
        preper_data.clean_special_character
    )
    
    # Génération des embeddings
    preper_data.transform_data()

3. Fonction de nettoyage du texte

def clean_special_character(self, text):
    if not isinstance(text, str):
        return ""
    
    # Suppression des balises HTML
    html_pattern = re.compile(r'<[^>]+>')
    if html_pattern.search(text):
        return BeautifulSoup(text, "html.parser").get_text(separator=" ")
    else:
        # Normalisation des espaces
        text = re.sub(r'\n+', ' ', text)
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

4. Génération des embeddings

def transform_data(self):
    # Utilisation du modèle multilingue
    self.model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")
    
    # Génération des embeddings pour chaque critique
    self.data["review_embedding"] = self.data["review_content"].apply(
        lambda x: self.model.encode(x)
    )
    return self.data

5. Calcul de similarité et recommandations

def find_top_5_similar_reviews(self, input_cretique, similarity_threshold=0.6):
    # Génération de l'embedding pour la critique utilisateur
    input_cretique_embedding = self.model.encode(input_cretique)
    
    similarities = []
    for i, embedding in enumerate(self.data["review_embedding"]):
        # Calcul de la similarité cosinus
        similarity = cosine_similarity([input_cretique_embedding], [embedding])[0][0]
        similarities.append((i, similarity))
    
    # Filtrage par seuil et sélection du top 5
    filtered_similarities = [(i, score) for i, score in similarities 
                           if score > similarity_threshold]
    
    if not filtered_similarities:
        filtered_similarities = sorted(similarities, key=lambda x: x[1], reverse=True)[:5]
    
    top_5 = sorted(filtered_similarities, key=lambda x: x[1], reverse=True)[:5]
    
    # Construction des résultats
    results = []
    for i, score in top_5:
        results.append({
            "index": i,
            "similarity": score,
            "review": self.data.iloc[i]["review_content"]
        })
    return pd.DataFrame(results)

6. Interface interactive

print("Système de recommandation prêt!\n")
while True:
    user_input = input("Entrez votre critique pour le film de fightclub (ou 'exit' pour quitter): ").strip()
    
    if user_input.lower() == 'exit':
        print("Au revoir!")
        break
    
    if not user_input:
        print("Veuillez entrer une critique valide.")
        continue
    
    try:
        print(f"\nRecherche de critiques similaires à: '{user_input}'")
        similar_reviews = preper_data.find_top_5_similar_reviews(user_input)
        
        print("\nTop 5 critiques similaires:")
        for idx, row in similar_reviews.iterrows():
            print(f"Score: {row['similarity']:.3f}")
            print(f"Critique: {row['review']}")
            
    except Exception as e:
        print(f"Erreur lors de la recherche: {e}")