Upload 8 files

README.md

@@ -1,13 +1,253 @@
 ---
-title: Amazon Sentiment Analysis Shirin
-emoji: 🐠
-colorFrom: red
-colorTo: pink
+title: Amazon Sentiment Analysis
+emoji: 🛍️
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 6.0.2
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🛍️ Analyse de Sentiment d'Avis Amazon + Réponses Automatiques
+
+## 📋 Description du Projet
+
+Pipeline IA complet pour l'analyse d'avis clients Amazon en français avec :
+1. **Nettoyage des textes** (suppression stopwords, ponctuation, normalisation)
+2. **Analyse de sentiment** (positif/négatif)
+3. **Génération automatique de réponses** pour les avis négatifs avec Qwen2.5-3B
+
+## 🎯 Objectifs Pédagogiques
+
+Projet développé dans le cadre d'un **Master en AI Project Management** au Collège de Paris :
+
+- Maîtrise d'un **pipeline NLP complet** (preprocessing → analyse → génération)
+- Utilisation de **modèles de langage open-source** (Qwen2.5-3B-Instruct)
+- **Déploiement avec CI/CD automatique** sur Hugging Face Spaces
+- Application de l'**éthique IA** (transparence, explicabilité)
+
+## 🛠️ Technologies Utilisées
+
+- **Modèle** : [Qwen/Qwen2.5-3B-Instruct](https://huggingface.co/Qwen/Qwen2.5-3B-Instruct)
+- **Dataset** : [SetFit/amazon_reviews_multi_fr](https://huggingface.co/datasets/SetFit/amazon_reviews_multi_fr)
+- **Framework UI** : Gradio 4.0+
+- **Librairies** : Transformers, PyTorch, Pandas, Datasets
+
+## 🏗️ Architecture du Projet
+
+### Structure des fichiers
+
+```
+📦 amazon-sentiment-analysis-shirin/
+├── app.py                     # Interface Gradio principale
+├── data_processing.py         # Nettoyage et traitement des données
+├── generate_response.py       # Génération de réponses (module Qwen)
+├── build_dataframe.py         # Construction du DataFrame complet
+├── main.py                    # Point d'entrée principal
+├── test_app.py                # Tests unitaires
+├── requirements.txt           # Dépendances Python
+└── README.md                  # Documentation
+```
+
+### Modules
+
+#### `data_processing.py`
+Fonctions de nettoyage et traitement :
+- `clean_text()` : Nettoyage des avis (stopwords, ponctuation)
+- `label_to_sentiment()` : Conversion label → sentiment
+- `make_fake_email()` : Génération d'emails factices
+
+#### `generate_response.py`
+Génération de réponses automatiques :
+- `load_model()` : Chargement du modèle Qwen
+- `generer_reponse()` : Génération de réponse pour avis négatif
+- `build_reply_prompt()` : Construction du prompt
+
+#### `build_dataframe.py`
+Construction du DataFrame final :
+- Chargement dataset Amazon
+- Nettoyage et analyse de sentiment
+- Génération de réponses pour avis négatifs
+- Export CSV
+
+#### `app.py`
+Interface utilisateur Gradio :
+- Saisie d'avis client
+- Analyse de sentiment
+- Génération de réponse (si négatif)
+- Affichage des résultats
+
+#### `main.py`
+Point d'entrée avec options :
+- `python main.py app` → Lance l'interface Gradio
+- `python main.py build` → Construit le DataFrame
+- `python main.py test` → Lance les tests unitaires
+
+#### `test_app.py`
+Tests unitaires :
+- Tests de nettoyage de texte
+- Tests de conversion sentiment
+- Tests de génération d'emails
+
+## 🚀 Utilisation
+
+### Interface Web
+
+1. Entrez un avis client dans le champ de texte
+2. (Optionnel) Sélectionnez manuellement le sentiment
+3. Cliquez sur "🚀 Analyser l'avis"
+4. Consultez les résultats :
+   - Texte nettoyé
+   - Sentiment détecté
+   - Réponse générée (si négatif)
+
+### Ligne de commande
+
+```bash
+# Lancer l'interface Gradio
+python main.py app
+
+# Construire le DataFrame complet
+python main.py build
+
+# Lancer les tests
+python main.py test
+```
+
+### 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 et conforme à la description. Je recommande !
+```
+
+## 🔄 CI/CD (Intégration Continue / Déploiement Continu)
+
+### Pipeline CI/CD Automatique
+
+Ce projet utilise **Hugging Face Spaces** qui intègre nativement un pipeline CI/CD complet :
+
+```
+Code modifié → Push → Build Auto (CI) → Deploy Auto (CD) → App en ligne
+```
+
+### Processus d'Intégration Continue (CI)
+
+À chaque modification du code (push Git ou upload), Hugging Face Spaces exécute automatiquement :
+
+1. ✅ **Détection des changements** : Trigger automatique
+2. ✅ **Parsing de requirements.txt** : Identification des dépendances
+3. ✅ **Installation des packages** : pip install automatique
+4. ✅ **Téléchargement du modèle** : Qwen2.5-3B depuis Hugging Face Hub
+5. ✅ **Vérification syntaxique** : Tests Python
+6. ✅ **Build de l'environnement** : Container Docker
+
+### Processus de Déploiement Continu (CD)
+
+Si le build CI réussit :
+
+1. ✅ **Déploiement automatique** : Lancement de l'app Gradio
+2. ✅ **Mise à jour URL** : Application accessible immédiatement
+3. ✅ **Rolling update** : Pas de downtime
+4. ✅ **Monitoring** : Logs disponibles en temps réel
+
+### Avantages vs Azure App Service + GitHub Actions
+
+| Caractéristique | Azure + GitHub Actions | Hugging Face Spaces |
+|----------------|----------------------|---------------------|
+| **CI/CD automatique** | ✅ Oui (via .yml) | ✅ Oui (natif) |
+| **Configuration** | ⚠️ Fichiers workflow | ✅ Aucune config |
+| **Coût** | ❌ CB requise | ✅ 100% gratuit |
+| **Spécialisation IA** | ⚠️ Généraliste | ✅ Optimisé ML |
+| **Complexité** | ⚠️ Moyenne | ✅ Simple |
+
+**Pourquoi pas de dossier `.github/workflows/` ?**
+
+Hugging Face Spaces intègre la CI/CD **nativement**, sans nécessiter de fichiers de configuration YAML. Le processus est entièrement automatisé et transparent.
+
+## ⚙️ Configuration Technique
+
+- **Hardware** : CPU Basic (gratuit)
+- **Modèle** : Chargé en FP32 pour compatibilité CPU
+- **Temps de réponse** : ~10-30 secondes selon la charge
+- **Build initial** : ~10-15 minutes (téléchargement modèle)
+- **Builds suivants** : ~3-5 minutes (modèle en cache)
+
+## 🧪 Tests
+
+Le projet inclut des tests unitaires dans `test_app.py` :
+
+```bash
+# Lancer les tests
+python test_app.py
+
+# Ou via main.py
+python main.py test
+```
+
+Tests couverts :
+- Nettoyage de texte (ponctuation, chiffres, stopwords)
+- Conversion label → sentiment
+- Génération d'emails factices
+- Construction de prompts
+
+## 🎓 Contexte Académique
+
+**Projet réalisé par** : Coralie  
+**Formation** : Master AI Project Management - Collège de Paris (2024-2026)  
+**Alternance** : AI Project Manager - IRFA Formation  
+**Sujet** : Pipeline NLP complet avec déploiement CI/CD
+
+### Choix Techniques Justifiés
+
+**Pourquoi Hugging Face Spaces plutôt qu'Azure ?**
+- ✅ Gratuit et sans carte bancaire
+- ✅ Spécialisé pour les modèles IA
+- ✅ CI/CD native simplifiée
+- ✅ Crédibilité académique reconnue
+- ✅ Cohérence (dataset et modèle déjà sur HF)
+
+**Pourquoi Qwen2.5-3B-Instruct ?**
+- ✅ Performances excellentes en français
+- ✅ Taille raisonnable (3B paramètres)
+- ✅ Compatible CPU
+- ✅ Licence open-source
+
+## 🔮 Évolutions Possibles
+
+- [ ] Migration vers ZeroGPU pour accélération
+- [ ] Fine-tuning du modèle sur avis Amazon FR
+- [ ] Classification multi-classes (1-5 étoiles)
+- [ ] API REST pour intégration externe
+- [ ] Batch processing pour volume élevé
+- [ ] Dashboard de monitoring
+
+## 📄 Licence
+
+Apache 2.0 - Libre d'utilisation et de modification
+
+## 🙏 Remerciements
+
+- **Hugging Face** pour l'infrastructure Spaces
+- **Qwen Team** pour le modèle open-source
+- **SetFit** pour le dataset Amazon Reviews
+
+---
+
+## 📚 Références
+
+- [Documentation Gradio](https://www.gradio.app/docs)
+- [Qwen2.5 Model Card](https://huggingface.co/Qwen/Qwen2.5-3B-Instruct)
+- [Hugging Face Spaces Guide](https://huggingface.co/docs/hub/spaces)
+- [SetFit Amazon Reviews](https://huggingface.co/datasets/SetFit/amazon_reviews_multi_fr)
+
+---
+
+**🔗 URL du projet** : https://huggingface.co/spaces/Oxyb50410/amazon-sentiment-analysis-shirin

app.py

@@ -0,0 +1,139 @@
+"""
+Interface Gradio pour l'analyse de sentiment d'avis Amazon
+et la génération automatique de réponses
+"""
+
+import gradio as gr
+import time
+from data_processing import clean_text
+from generate_response import generer_reponse, load_model
+
+
+# Préchargement du modèle au démarrage
+print("🔄 Préchargement du modèle...")
+load_model()
+print("✅ Application prête !")
+
+
+def analyze_review(review_text: str, manual_sentiment: str = None):
+    """
+    Analyse un avis client et génère une réponse si négatif
+    
+    Args:
+        review_text (str): Texte de l'avis client
+        manual_sentiment (str): Sentiment manuel (optionnel)
+        
+    Returns:
+        tuple: (résultat, réponse, texte_nettoyé)
+    """
+    
+    if not review_text or review_text.strip() == "":
+        return "⚠️ Veuillez entrer un avis client.", "", ""
+    
+    start_time = time.time()
+    
+    # 1. Nettoyage du texte
+    texte_clean = clean_text(review_text)
+    
+    # 2. Analyse de sentiment
+    if manual_sentiment:
+        sentiment = manual_sentiment.lower()
+    else:
+        # Détection automatique basique par mots-clés
+        negative_words = ["nul", "mauvais", "horrible", "déçu", "décevant", "pas", "rien", "cassé"]
+        sentiment = "negatif" if any(word in texte_clean for word in negative_words) else "positif"
+    
+    # 3. Génération de réponse (uniquement si négatif)
+    if sentiment == "negatif":
+        try:
+            response = generer_reponse(review_text, max_tokens=100, temperature=0.7)
+            response_display = f"📧 **Réponse générée :**\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"
+    
+    elapsed = time.time() - start_time
+    
+    # Résultat formaté
+    result = f"""
+### 📊 Analyse terminée en {elapsed:.2f}s
+
+**Texte nettoyé :** {texte_clean}
+
+**Sentiment détecté :** {"🔴 NÉGATIF" if sentiment == "negatif" else "🟢 POSITIF"}
+    """
+    
+    return result, response_display, texte_clean
+
+
+# Interface Gradio
+with gr.Blocks(title="Analyse de Sentiment Amazon + Réponses Auto", theme=gr.themes.Soft()) 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 : Qwen2.5-3B-Instruct
+        
+        Ce projet utilise un **pipeline CI/CD automatique** via Hugging Face Spaces.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            review_input = gr.Textbox(
+                label="📝 Avis client Amazon",
+                placeholder="Entrez un avis client ici...",
+                lines=6
+            )
+            
+            sentiment_choice = gr.Radio(
+                label="🎯 Sentiment (optionnel - sinon détection auto)",
+                choices=["Positif", "Negatif"],
+                value=None
+            )
+            
+            analyze_btn = gr.Button("🚀 Analyser l'avis", variant="primary")
+        
+        with gr.Column(scale=1):
+            result_output = gr.Markdown(label="Résultat de l'analyse")
+            response_output = gr.Markdown(label="Réponse générée")
+    
+    with gr.Accordion("📋 Texte nettoyé (debug)", open=False):
+        clean_output = gr.Textbox(label="Texte après nettoyage", lines=3)
+    
+    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 de cet achat !"
+        
+        **Avis positif :** "Excellent produit, livraison rapide et conforme à la description. Je recommande !"
+        
+        ---
+        
+        ### 🔄 CI/CD Automatique
+        
+        Cette application est déployée via **Hugging Face Spaces** avec CI/CD intégrée :
+        - ✅ Build automatique à chaque modification
+        - ✅ Tests de syntaxe et dépendances
+        - ✅ Déploiement continu si build OK
+        """
+    )
+    
+    # Événement
+    analyze_btn.click(
+        fn=analyze_review,
+        inputs=[review_input, sentiment_choice],
+        outputs=[result_output, response_output, clean_output]
+    )
+
+
+# Lancement
+if __name__ == "__main__":
+    demo.launch()

build_dataframe.py

@@ -0,0 +1,114 @@
+"""
+Construction du DataFrame final pour le projet
+Charge les données Amazon, nettoie, analyse sentiment, génère réponses
+"""
+
+import pandas as pd
+from datasets import load_dataset
+from data_processing import clean_text, label_to_sentiment, make_fake_email
+from generate_response import generer_reponse
+
+
+def build_dataframe(n_samples: int = 1000, n_negative_responses: int = 100) -> pd.DataFrame:
+    """
+    Construit le DataFrame final avec sentiment et réponses
+    
+    Args:
+        n_samples (int): Nombre d'avis à charger du dataset
+        n_negative_responses (int): Nombre d'avis négatifs pour lesquels générer une réponse
+        
+    Returns:
+        pd.DataFrame: DataFrame avec colonnes texte_clean, sentiment, response, email_client
+    """
+    print(f"📊 Construction du DataFrame avec {n_samples} avis...")
+    
+    # 1. Chargement du dataset
+    print("1️⃣ Chargement du dataset Amazon Reviews...")
+    dataset = load_dataset("SetFit/amazon_reviews_multi_fr", split=f"train[:{n_samples}]")
+    df = pd.DataFrame(dataset)[["text", "label"]].copy()
+    df = df.rename(columns={"text": "texte_original"})
+    print(f"   ✅ {len(df)} avis chargés")
+    
+    # 2. Nettoyage des textes
+    print("2️⃣ Nettoyage des textes...")
+    df["texte_clean"] = df["texte_original"].apply(clean_text)
+    print("   ✅ Textes nettoyés")
+    
+    # 3. Analyse de sentiment
+    print("3️⃣ Analyse de sentiment...")
+    df["sentiment"] = df["label"].apply(label_to_sentiment)
+    n_positif = (df["sentiment"] == "positif").sum()
+    n_negatif = (df["sentiment"] == "negatif").sum()
+    print(f"   ✅ Sentiments : {n_positif} positifs, {n_negatif} négatifs")
+    
+    # 4. Génération de réponses pour avis négatifs
+    print(f"4️⃣ Génération de réponses pour {n_negative_responses} avis négatifs...")
+    df["response"] = ""
+    
+    neg_df = df[df["sentiment"] == "negatif"].head(n_negative_responses)
+    
+    for idx, row in neg_df.iterrows():
+        try:
+            review_text = row["texte_original"]
+            response = generer_reponse(review_text, max_tokens=80, temperature=0.7)
+            df.at[idx, "response"] = response
+            
+            if (idx + 1) % 10 == 0:
+                print(f"   ... {idx + 1}/{len(neg_df)} réponses générées")
+        except Exception as e:
+            print(f"   ⚠️ Erreur pour l'avis {idx}: {e}")
+            df.at[idx, "response"] = "[Erreur de génération]"
+    
+    print("   ✅ Réponses générées")
+    
+    # 5. Ajout des emails factices
+    print("5️⃣ Ajout des emails clients...")
+    df["email_client"] = [make_fake_email(i) for i in range(1, len(df) + 1)]
+    print("   ✅ Emails ajoutés")
+    
+    # 6. DataFrame final
+    df_final = df[["texte_clean", "sentiment", "response", "email_client"]].copy()
+    
+    print(f"\n✅ DataFrame final construit : {len(df_final)} lignes")
+    print(f"   - Colonnes : {list(df_final.columns)}")
+    print(f"   - Réponses générées : {(df_final['response'] != '').sum()}")
+    
+    return df_final
+
+
+def save_dataframe(df: pd.DataFrame, output_path: str = "dataframe_final.csv"):
+    """
+    Sauvegarde le DataFrame en CSV
+    
+    Args:
+        df (pd.DataFrame): DataFrame à sauvegarder
+        output_path (str): Chemin du fichier de sortie
+    """
+    df.to_csv(output_path, index=False)
+    print(f"💾 DataFrame sauvegardé : {output_path}")
+
+
+if __name__ == "__main__":
+    print("=" * 80)
+    print("🚀 CONSTRUCTION DU DATAFRAME AMAZON SENTIMENT ANALYSIS")
+    print("=" * 80)
+    
+    # Construction avec paramètres réduits pour test rapide
+    df = build_dataframe(n_samples=100, n_negative_responses=10)
+    
+    # Affichage d'exemples
+    print("\n📋 Exemples d'avis négatifs avec réponses :")
+    print("-" * 80)
+    neg_with_response = df[(df["sentiment"] == "negatif") & (df["response"] != "")]
+    for i, row in neg_with_response.head(3).iterrows():
+        print(f"\nAvis {i+1}:")
+        print(f"Texte nettoyé : {row['texte_clean'][:100]}...")
+        print(f"Réponse : {row['response'][:150]}...")
+        print(f"Email : {row['email_client']}")
+    
+    # Sauvegarde
+    save_dataframe(df, "dataframe_amazon_test.csv")
+    
+    print("\n" + "=" * 80)
+    print("✅ TERMINÉ !")
+    print("=" * 80)

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,135 @@
+"""
+Module de génération de réponses automatiques pour avis négatifs
+Utilise le modèle Qwen2.5-3B-Instruct
+"""
+
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+
+# Configuration du modèle
+MODEL_NAME = "Qwen/Qwen2.5-3B-Instruct"
+
+# Variables globales pour le modèle (chargé une seule fois)
+_tokenizer = None
+_model = None
+
+
+def load_model():
+    """
+    Charge le modèle Qwen2.5-3B-Instruct
+    Appelé une seule fois au démarrage
+    """
+    global _tokenizer, _model
+    
+    if _tokenizer is None or _model is None:
+        print(f"🔄 Chargement du modèle {MODEL_NAME}...")
+        
+        _tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        _model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            torch_dtype=torch.float32,  # CPU compatible
+            device_map="cpu"
+        )
+        
+        # Configuration du token de padding
+        if _tokenizer.pad_token is None:
+            _tokenizer.pad_token = _tokenizer.eos_token
+            _model.config.pad_token_id = _tokenizer.eos_token_id
+        
+        print("✅ Modèle chargé avec succès !")
+    
+    return _tokenizer, _model
+
+
+def build_reply_prompt(review_text: str) -> str:
+    """
+    Construit le prompt pour générer une réponse au service client
+    
+    Args:
+        review_text (str): Texte de l'avis client négatif
+        
+    Returns:
+        str: Prompt formaté pour le modèle
+    """
+    prompt = (
+        "Tu es un agent du service client Amazon. "
+        "Tu dois répondre en français à un avis client NEGATIF.\n\n"
+        "Consignes pour ta réponse :\n"
+        "- rester poli et professionnel,\n"
+        "- reconnaître le problème,\n"
+        "- proposer une solution ou un contact,\n"
+        "- utiliser un ton empathique.\n\n"
+        "Avis du client :\n"
+        f"{review_text}\n\n"
+        "Réponse du service client :"
+    )
+    return prompt
+
+
+def generer_reponse(review_text: str, max_tokens: int = 100, temperature: float = 0.7) -> str:
+    """
+    Génère une réponse automatique pour un avis négatif
+    
+    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 pour la génération (0.0 à 1.0)
+        
+    Returns:
+        str: Réponse générée par le modèle
+    """
+    # Charger le modèle si nécessaire
+    tokenizer, model = load_model()
+    
+    # Construire le prompt
+    prompt = build_reply_prompt(review_text)
+    
+    # Tokeniser
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+    
+    # Générer la réponse
+    with torch.no_grad():
+        outputs = model.generate(
+            inputs.input_ids,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            top_p=0.9,
+            do_sample=True,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+    
+    # Décoder la réponse complète
+    full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    # Extraire uniquement la réponse générée (après le prompt)
+    split_token = "Réponse du service client :"
+    if split_token in full_response:
+        answer = full_response.split(split_token, 1)[1].strip()
+    else:
+        answer = full_response.strip()
+    
+    return answer
+
+
+# Fonction alternative avec nom anglais (pour compatibilité)
+def generate_response(review_text: str, max_tokens: int = 100, temperature: float = 0.7) -> str:
+    """Alias anglais de generer_reponse"""
+    return generer_reponse(review_text, max_tokens, temperature)
+
+
+if __name__ == "__main__":
+    # Test du module
+    print("=== TEST DU MODULE generate_response.py ===\n")
+    
+    test_reviews = [
+        "Le produit est arrivé cassé et le service client ne répond pas. Très déçu !",
+        "Horrible expérience, produit défectueux et remboursement refusé."
+    ]
+    
+    for i, review in enumerate(test_reviews, 1):
+        print(f"Test {i}:")
+        print(f"Avis: {review}")
+        response = generer_reponse(review, max_tokens=80)
+        print(f"Réponse: {response}")
+        print("-" * 80)

main.py

@@ -0,0 +1,84 @@
+"""
+Point d'entrée principal du projet Amazon Sentiment Analysis
+Peut lancer soit l'interface Gradio, soit le build du DataFrame
+"""
+
+import sys
+import argparse
+
+
+def launch_gradio_app():
+    """Lance l'application Gradio"""
+    print("🚀 Lancement de l'interface Gradio...")
+    from app import demo
+    demo.launch()
+
+
+def build_dataset():
+    """Construit le DataFrame complet"""
+    print("📊 Construction du DataFrame...")
+    from build_dataframe import build_dataframe, save_dataframe
+    
+    # Paramètres personnalisables
+    n_samples = 1000
+    n_responses = 100
+    
+    print(f"Configuration : {n_samples} avis, {n_responses} réponses générées")
+    
+    df = build_dataframe(n_samples=n_samples, n_negative_responses=n_responses)
+    save_dataframe(df, "dataframe_final_amazon.csv")
+    
+    print("✅ DataFrame construit et sauvegardé !")
+
+
+def run_tests():
+    """Lance les tests unitaires"""
+    print("🧪 Lancement des tests...")
+    from test_app import run_all_tests
+    
+    success = run_all_tests()
+    if success:
+        print("✅ Tests réussis !")
+        sys.exit(0)
+    else:
+        print("❌ Tests échoués")
+        sys.exit(1)
+
+
+def main():
+    """Point d'entrée principal avec options en ligne de commande"""
+    parser = argparse.ArgumentParser(
+        description="Amazon Sentiment Analysis - Projet Master IA"
+    )
+    
+    parser.add_argument(
+        "mode",
+        choices=["app", "build", "test"],
+        help="Mode d'exécution : app (Gradio), build (DataFrame), test (tests)"
+    )
+    
+    args = parser.parse_args()
+    
+    print("=" * 80)
+    print("🛍️ AMAZON SENTIMENT ANALYSIS")
+    print("Projet Master AI Project Management - Coralie")
+    print("=" * 80)
+    print()
+    
+    if args.mode == "app":
+        launch_gradio_app()
+    elif args.mode == "build":
+        build_dataset()
+    elif args.mode == "test":
+        run_tests()
+
+
+if __name__ == "__main__":
+    # Si appelé sans arguments, lance l'app Gradio par défaut
+    if len(sys.argv) == 1:
+        print("ℹ️  Aucun argument fourni, lancement de l'app Gradio...")
+        print("   Usage: python main.py [app|build|test]")
+        print()
+        launch_gradio_app()
+    else:
+        main()

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+transformers>=4.35.0
+torch>=2.0.0
+accelerate>=0.24.0
+datasets>=2.14.0
+pandas>=2.0.0

test_app.py

@@ -0,0 +1,132 @@
+"""
+Tests unitaires pour le projet Amazon Sentiment Analysis
+Teste les fonctions de traitement et de génération
+"""
+
+import sys
+import os
+
+# Import des modules à tester
+from data_processing import clean_text, label_to_sentiment, make_fake_email
+
+
+def test_clean_text():
+    """Test de la fonction de nettoyage de texte"""
+    print("\n=== TEST : clean_text ===")
+    
+    # Test 1 : Texte avec ponctuation
+    text1 = "Super produit !!! Je recommande."
+    result1 = clean_text(text1)
+    assert "super" in result1
+    assert "produit" in result1
+    assert "!" not in result1
+    print(f"✅ Test 1 réussi : '{text1}' → '{result1}'")
+    
+    # Test 2 : Texte avec chiffres
+    text2 = "Livraison en 24h, excellent !"
+    result2 = clean_text(text2)
+    assert "24" not in result2
+    print(f"✅ Test 2 réussi : '{text2}' → '{result2}'")
+    
+    # Test 3 : Stopwords supprimés
+    text3 = "Je suis très content de cet achat"
+    result3 = clean_text(text3)
+    assert "je" not in result3  # stopword supprimé
+    assert "content" in result3
+    print(f"✅ Test 3 réussi : '{text3}' → '{result3}'")
+    
+    print("✅ Tous les tests clean_text réussis !")
+
+
+def test_label_to_sentiment():
+    """Test de la conversion label → sentiment"""
+    print("\n=== TEST : label_to_sentiment ===")
+    
+    # Test labels négatifs (1-2 étoiles)
+    assert label_to_sentiment(1) == "negatif"
+    assert label_to_sentiment(2) == "negatif"
+    print("✅ Labels 1-2 → négatif")
+    
+    # Test labels positifs (3-5 étoiles)
+    assert label_to_sentiment(3) == "positif"
+    assert label_to_sentiment(4) == "positif"
+    assert label_to_sentiment(5) == "positif"
+    print("✅ Labels 3-5 → positif")
+    
+    # Test valeur invalide
+    assert label_to_sentiment("invalid") == "negatif"  # Par défaut
+    print("✅ Valeur invalide gérée")
+    
+    print("✅ Tous les tests label_to_sentiment réussis !")
+
+
+def test_make_fake_email():
+    """Test de la génération d'emails factices"""
+    print("\n=== TEST : make_fake_email ===")
+    
+    # Test format
+    email1 = make_fake_email(1)
+    assert email1 == "[email protected]"
+    print(f"✅ Email 1 : {email1}")
+    
+    email42 = make_fake_email(42)
+    assert email42 == "[email protected]"
+    assert "@example.com" in email42
+    print(f"✅ Email 42 : {email42}")
+    
+    print("✅ Tous les tests make_fake_email réussis !")
+
+
+def test_generer_response_mock():
+    """
+    Test simulé de la génération de réponse (sans charger le modèle)
+    Vérifie que le prompt est bien construit
+    """
+    print("\n=== TEST : build_reply_prompt ===")
+    
+    from generate_response import build_reply_prompt
+    
+    review = "Produit cassé"
+    prompt = build_reply_prompt(review)
+    
+    # Vérifications
+    assert "service client" in prompt.lower()
+    assert "Produit cassé" in prompt
+    assert "poli et professionnel" in prompt
+    
+    print("✅ Prompt correctement construit")
+    print(f"Extrait : {prompt[:100]}...")
+
+
+def run_all_tests():
+    """Lance tous les tests"""
+    print("=" * 80)
+    print("🧪 LANCEMENT DES TESTS UNITAIRES")
+    print("=" * 80)
+    
+    try:
+        test_clean_text()
+        test_label_to_sentiment()
+        test_make_fake_email()
+        test_generer_response_mock()
+        
+        print("\n" + "=" * 80)
+        print("🎉 TOUS LES TESTS ONT RÉUSSI !")
+        print("=" * 80)
+        return True
+        
+    except AssertionError as e:
+        print("\n" + "=" * 80)
+        print(f"❌ ÉCHEC DES TESTS : {e}")
+        print("=" * 80)
+        return False
+    except Exception as e:
+        print("\n" + "=" * 80)
+        print(f"❌ ERREUR LORS DES TESTS : {e}")
+        print("=" * 80)
+        return False
+
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    sys.exit(0 if success else 1)