Upload 4 files

app.py

@@ -0,0 +1,139 @@
+"""
+Application Gradio pour l'analyse de sentiment d'avis Amazon
+avec génération automatique de réponses pour le service client
+
+VERSION avec CroissantLLMChat - Modèle français bilingue 1.3B
+"""
+
+import gradio as gr
+from data_processing import clean_text, label_to_sentiment
+from generate_response import generer_reponse, load_model
+import time
+
+# Précharger le modèle CroissantLLMChat au démarrage
+print("🥐 Préchargement de CroissantLLMChat (modèle français 1.3B)...")
+load_model()
+print("✅ Application prête !")
+
+def analyze_review(review_text: str, sentiment_choice: str = "auto") -> tuple:
+    """
+    Analyse un avis client et génère une réponse si négatif
+    
+    Args:
+        review_text (str): Texte de l'avis client
+        sentiment_choice (str): "auto" pour détection auto, ou "positif"/"negatif"
+        
+    Returns:
+        tuple: (texte_nettoye, sentiment_affichage, reponse_affichage, temps)
+    """
+    start_time = time.time()
+    
+    # 1. Nettoyage du texte
+    cleaned = clean_text(review_text)
+    
+    # 2. Détection du sentiment
+    if sentiment_choice == "auto":
+        # Détection automatique basique
+        mots_negatifs = ["mauvais", "nul", "déçu", "cassé", "retard", "problème", 
+                        "défectueux", "horrible", "arnaque", "pas", "ne", "aucun",
+                        "inacceptable", "mécontentent", "insatisfait"]
+        
+        mots_avis = cleaned.lower().split()
+        count_negatif = sum(1 for mot in mots_avis if any(neg in mot for neg in mots_negatifs))
+        
+        sentiment = "negatif" if count_negatif >= 1 else "positif"
+    else:
+        sentiment = sentiment_choice.lower()
+    
+    # Affichage du sentiment
+    if sentiment == "negatif":
+        sentiment_display = "🔴 **NÉGATIF**"
+    else:
+        sentiment_display = "🟢 **POSITIF**"
+    
+    # 3. Génération de réponse (uniquement si négatif)
+    if sentiment == "negatif":
+        try:
+            response = generer_reponse(cleaned, max_tokens=120, temperature=0.7)
+            response_display = f"📧 **Réponse générée (CroissantLLMChat) :**\n\n{response}"
+        except Exception as e:
+            response = f"[Erreur : {e}]"
+            response_display = f"❌ Erreur lors de la génération : {e}"
+    else:
+        response = ""
+        response_display = "✅ Avis positif - Aucune réponse nécessaire"
+    
+    # Temps d'exécution
+    elapsed_time = time.time() - start_time
+    
+    return (
+        f"**Texte nettoyé :** {cleaned}",
+        f"**Sentiment détecté :** {sentiment_display}",
+        response_display,
+        f"⏱️ **Analyse terminée en {elapsed_time:.2f}s**"
+    )
+
+# Interface Gradio
+with gr.Blocks(title="Analyse de Sentiment Amazon + Réponses Auto") as demo:
+    
+    gr.Markdown("""
+    # 🛍️ Analyse de Sentiment d'Avis Amazon
+    ## Pipeline IA complet : Nettoyage + Sentiment + Génération de réponses
+    
+    **Projet Master IA** - Coralie | **Modèle** : CroissantLLMChat (1.3B, bilingue FR/EN)
+    
+    🥐 **Version avec CroissantLLM** - Modèle français développé par CentraleSupélec.  
+    Ce projet utilise un **pipeline CI/CD automatique** via Hugging Face Spaces.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📝 Avis client Amazon")
+            
+            review_input = gr.Textbox(
+                label="Avis client Amazon",
+                placeholder="Le produit est arrivé cassé et le service client ne répond pas. Très déçu !",
+                lines=5
+            )
+            
+            sentiment_radio = gr.Radio(
+                choices=["auto", "positif", "negatif"],
+                value="auto",
+                label="🎯 Sentiment (optionnel - sinon détection auto)",
+                info="Laissez sur 'auto' pour détection automatique"
+            )
+            
+            analyze_btn = gr.Button("🔍 Analyser l'avis", variant="primary")
+        
+        with gr.Column():
+            gr.Markdown("### 📊 Résultats de l'analyse")
+            
+            timing_output = gr.Markdown(label="Temps d'exécution")
+            cleaned_output = gr.Markdown(label="Texte nettoyé")
+            sentiment_output = gr.Markdown(label="Sentiment")
+            response_output = gr.Markdown(label="Réponse générée")
+    
+    # Bouton d'analyse
+    analyze_btn.click(
+        fn=analyze_review,
+        inputs=[review_input, sentiment_radio],
+        outputs=[cleaned_output, sentiment_output, response_output, timing_output]
+    )
+    
+    # Section d'exemples
+    gr.Markdown("""
+    ---
+    ### 💡 Exemples d'avis à tester :
+    
+    **Avis négatif :** "Le produit est arrivé cassé et le service client ne répond pas. Très déçu !"
+    
+    **Avis positif :** "Excellent produit, livraison rapide. Je recommande !"
+    """)
+    
+    # Debug toggle
+    with gr.Accordion("🔧 Texte nettoyé (debug)", open=False):
+        gr.Markdown("Affiche le texte après nettoyage")
+
+# Lancer l'application
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

data_processing.py

@@ -0,0 +1,102 @@
+"""
+Module de traitement des données pour l'analyse de sentiment
+Nettoyage des textes et labellisation
+"""
+
+import re
+import string
+
+# Liste des stopwords français
+FRENCH_STOPWORDS = {
+    "a", "à", "ai", "aie", "aient", "aies", "ait", "alors", "as", "au", "aucun", "aura",
+    "aurai", "auraient", "aurais", "aurait", "auve", "avec", "avez", "aviez", "avions",
+    "avoir", "avons", "bon", "car", "ce", "cela", "ces", "cet", "cette", "ceux", "chaque",
+    "comme", "d", "dans", "de", "des", "du", "elle", "en", "encore", "est", "et", "eu",
+    "fait", "faites", "fois", "ici", "il", "ils", "je", "la", "le", "les", "leur", "lui",
+    "mais", "me", "mes", "moi", "mon", "ne", "nos", "notre", "nous", "on", "ou", "par",
+    "pas", "pour", "plus", "qu", "que", "qui", "sa", "se", "ses", "son", "sur",
+    "ta", "te", "tes", "toi", "ton", "toujours", "tout", "tous", "très", "tu",
+    "un", "une", "vos", "votre", "vous", "y"
+}
+
+# Table de traduction pour remplacer la ponctuation par des espaces
+PUNCT_TABLE = str.maketrans({c: " " for c in string.punctuation})
+
+
+def clean_text(text: str) -> str:
+    """
+    Nettoie un texte d'avis client :
+    - Conversion en minuscules
+    - Suppression de la ponctuation
+    - Suppression des chiffres
+    - Suppression des stopwords français
+    - Normalisation des espaces
+    
+    Args:
+        text (str): Texte brut à nettoyer
+        
+    Returns:
+        str: Texte nettoyé
+    """
+    if not isinstance(text, str):
+        return ""
+    
+    # 1. Minuscules
+    text = text.lower()
+    
+    # 2. Suppression de la ponctuation
+    text = text.translate(PUNCT_TABLE)
+    
+    # 3. Suppression des chiffres
+    text = re.sub(r"\d+", " ", text)
+    
+    # 4. Normalisation des espaces
+    text = re.sub(r"\s+", " ", text).strip()
+    
+    # 5. Suppression des stopwords
+    tokens = [tok for tok in text.split() if tok not in FRENCH_STOPWORDS]
+    
+    return " ".join(tokens)
+
+
+def label_to_sentiment(label_value: int) -> str:
+    """
+    Convertit un label numérique (1-5 étoiles) en sentiment positif/négatif
+    
+    Args:
+        label_value (int): Note de 1 à 5 étoiles
+        
+    Returns:
+        str: "positif" si >= 3 étoiles, "negatif" sinon
+    """
+    try:
+        v = int(label_value)
+    except Exception:
+        v = 0
+    
+    return "positif" if v >= 3 else "negatif"
+
+
+def make_fake_email(index: int) -> str:
+    """
+    Génère un email factice pour un client
+    
+    Args:
+        index (int): Numéro du client
+        
+    Returns:
+        str: Email au format [email protected]
+    """
+    return f"client{index:05d}@example.com"
+
+
+if __name__ == "__main__":
+    # Tests
+    test_text = "Je suis TRÈS déçu de ce produit ! Il est arrivé cassé et le service client ne répond pas..."
+    print(f"Original : {test_text}")
+    print(f"Nettoyé  : {clean_text(test_text)}")
+    
+    print(f"\nLabel 1 → {label_to_sentiment(1)}")
+    print(f"Label 5 → {label_to_sentiment(5)}")
+    
+    print(f"\nEmail test : {make_fake_email(42)}")

generate_response.py

@@ -0,0 +1,173 @@
+"""
+Module de génération de réponses pour le service client Amazon
+Utilise CroissantLLMChat - Modèle bilingue français-anglais optimisé
+"""
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Modèle bilingue français-anglais spécialement conçu pour le français
+MODEL_NAME = "croissantllm/CroissantLLMChat-v0.1"
+
+# Variables globales pour le modèle
+model = None
+tokenizer = None
+
+def load_model():
+    """
+    Charge le modèle CroissantLLMChat et son tokenizer
+    CroissantLLM est un modèle 1.3B VRAIMENT bilingue (50% FR / 50% EN)
+    
+    Returns:
+        tuple: (model, tokenizer) chargés
+    """
+    global model, tokenizer
+    
+    print(f"🔄 Chargement du modèle {MODEL_NAME}...")
+    print("⏳ CroissantLLM est un modèle français de 1.3B paramètres (~2-3 GB)")
+    
+    # Charger le tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    
+    # Charger le modèle en float32 pour CPU
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME,
+        torch_dtype=torch.float32,
+        device_map="cpu",
+        low_cpu_mem_usage=True
+    )
+    
+    print("✅ Modèle CroissantLLMChat chargé avec succès !")
+    print("🥐 Modèle français bilingue prêt !")
+    
+    return model, tokenizer
+
+def build_chat_messages(review_text: str) -> list:
+    """
+    Construit les messages pour CroissantLLMChat
+    Format officiel avec apply_chat_template
+    
+    Args:
+        review_text (str): Texte de l'avis client négatif
+        
+    Returns:
+        list: Messages formatés pour CroissantLLMChat
+    """
+    # CroissantLLMChat utilise un format chat officiel
+    # Avec un message utilisateur clair
+    chat_messages = [
+        {
+            "role": "user", 
+            "content": f"""Tu es un agent du service client Amazon. Réponds en français à cet avis négatif avec empathie et professionnalisme :
+
+"{review_text}"
+
+Réponds en présentant des excuses, en reconnaissant le problème, et en proposant une solution concrète (remboursement ou échange)."""
+        }
+    ]
+    
+    return chat_messages
+
+def generer_reponse(review_text: str, max_tokens: int = 120, temperature: float = 0.7) -> str:
+    """
+    Génère une réponse au service client pour un avis négatif
+    Utilise CroissantLLMChat avec apply_chat_template (méthode officielle)
+    
+    Args:
+        review_text (str): Texte de l'avis client négatif
+        max_tokens (int): Nombre maximum de tokens à générer
+        temperature (float): Température de génération (0.7 = équilibré)
+        
+    Returns:
+        str: Réponse générée par le modèle EN FRANÇAIS
+    """
+    global model, tokenizer
+    
+    # Charger le modèle si pas encore fait
+    if model is None or tokenizer is None:
+        load_model()
+    
+    # Construire les messages au format chat
+    chat_messages = build_chat_messages(review_text)
+    
+    # Appliquer le template officiel de CroissantLLMChat
+    # C'est la méthode recommandée dans la documentation
+    chat_input = tokenizer.apply_chat_template(
+        chat_messages, 
+        tokenize=False, 
+        add_generation_prompt=True
+    )
+    
+    # Tokeniser le chat formaté
+    inputs = tokenizer(
+        chat_input,
+        return_tensors="pt",
+        max_length=512,
+        truncation=True
+    )
+    
+    # Générer avec CroissantLLMChat
+    # Température 0.7 recommandée (doc dit 0.3+ minimum)
+    with torch.no_grad():
+        outputs = model.generate(
+            inputs.input_ids,
+            attention_mask=inputs.attention_mask,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            do_sample=True,
+            top_p=0.9,
+            top_k=50,
+            repetition_penalty=1.2,
+            pad_token_id=tokenizer.eos_token_id,
+            eos_token_id=tokenizer.eos_token_id
+        )
+    
+    # MÉTHODE AMÉLIORÉE : Décoder UNIQUEMENT les nouveaux tokens
+    # On ne décode PAS le prompt d'entrée
+    input_length = inputs.input_ids.shape[1]
+    generated_tokens = outputs[0][input_length:]  # Prendre uniquement les tokens générés
+    
+    # Décoder uniquement la réponse générée
+    answer = tokenizer.decode(generated_tokens, skip_special_tokens=True)
+    
+    # Nettoyer les tokens spéciaux qui pourraient rester
+    special_tokens = ["<|im_start|>", "<|im_end|>", "assistant", "user", "system"]
+    for token in special_tokens:
+        answer = answer.replace(token, "")
+    
+    # Nettoyer espaces multiples
+    answer = ' '.join(answer.split())
+    answer = answer.strip()
+    
+    # Limiter à 3-4 phrases maximum
+    sentences = answer.split('.')
+    clean_sentences = [s.strip() for s in sentences if s.strip()]
+    if len(clean_sentences) > 4:
+        answer = '. '.join(clean_sentences[:4]) + '.'
+    else:
+        answer = '. '.join(clean_sentences)
+        if not answer.endswith('.'):
+            answer += '.'
+    
+    return answer
+
+# Test du module
+if __name__ == "__main__":
+    print("🧪 Test du module de génération avec CroissantLLMChat\n")
+    
+    # Charger le modèle
+    load_model()
+    
+    # Test 1
+    avis_test_1 = "Le produit est arrivé cassé et le service client ne répond pas. Très déçu !"
+    print(f"📝 Avis test 1: {avis_test_1}")
+    reponse_1 = generer_reponse(avis_test_1)
+    print(f"💬 Réponse: {reponse_1}\n")
+    
+    # Test 2
+    avis_test_2 = "Livraison en retard de 2 semaines, produit endommagé."
+    print(f"📝 Avis test 2: {avis_test_2}")
+    reponse_2 = generer_reponse(avis_test_2)
+    print(f"💬 Réponse: {reponse_2}\n")
+    
+    print("✅ Tests terminés !")

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.44.0
+transformers>=4.35.0
+torch>=2.0.0
+accelerate>=0.24.0
+datasets>=2.14.0
+pandas>=2.0.0
+sentencepiece>=0.1.99