Upload 6 files

README.md

@@ -1,11 +1,106 @@
 ---
-title: TP13
-emoji: 😻
-colorFrom: pink
-colorTo: pink
-sdk: static
+title: Radar Avis Clients
+emoji: 📡
+colorFrom: green
+colorTo: blue
+sdk: streamlit
+sdk_version: 1.62.0
+app_file: app.py
 pinned: false
 license: mit
+hardware: cpu-basic
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📡 Radar d'avis clients — Waaw Telecom (démo)
+
+Application Streamlit qui ingère un CSV d'avis clients en français et répond
+en moins d'une minute à trois questions : les clients sont-ils satisfaits ?
+De quoi parlent-ils ? Que faut-il retenir en trois lignes ?
+
+TP13 — Module 5 (Déploiement), Master IA.
+
+## Capture d'écran
+
+*(à ajouter après le premier lancement local — onglet Synthèse du tableau de bord)*
+
+## Format du CSV attendu
+
+| Colonne | Obligatoire | Description |
+|---|---|---|
+| `id` | oui | identifiant unique de l'avis |
+| `date` | oui | date de l'avis (`AAAA-MM-JJ`) |
+| `avis` | oui | texte de l'avis, en français |
+| `note` | non | note client de 1 à 5, sert de vérité terrain pour évaluer le modèle |
+
+Un jeu de démonstration de 200 avis synthétiques est fourni dans
+`data/exemple_avis.csv` et se charge automatiquement si aucun fichier n'est
+déposé.
+
+## Modèles utilisés
+
+| Tête | Modèle | Rôle |
+|---|---|---|
+| Sentiment | [cmarkea/distilcamembert-base-sentiment](https://huggingface.co/cmarkea/distilcamembert-base-sentiment) | classification positif / neutre / négatif + score de confiance |
+| Thèmes | [MoritzLaurer/mDeBERTa-v3-base-mnli-xnli](https://huggingface.co/MoritzLaurer/mDeBERTa-v3-base-mnli-xnli) | zero-shot multi-étiquettes sur les thèmes choisis |
+| Résumé | [plguillou/t5-base-fr-sum-cnndm](https://huggingface.co/plguillou/t5-base-fr-sum-cnndm) | synthèse des avis négatifs (activable, tête la plus lente) |
+
+## Évaluation contre la vérité terrain
+
+Quand la colonne `note` est présente, un onglet **Évaluation** calcule
+l'accuracy et le F1-score du modèle de sentiment contre la note client
+binarisée (≤2 négatif, ≥4 positif, 3 exclu), via la bibliothèque
+[`evaluate`](https://huggingface.co/docs/evaluate) (`evaluate.load("accuracy")`,
+`evaluate.load("f1")`) plutôt qu'un calcul manuel, et affiche la matrice de
+confusion correspondante.
+
+## Architecture du dépôt
+
+```
+radar-avis-clients/
+├── app.py                 # point d'entrée Streamlit (interface + tableau de bord)
+├── moteur.py               # chargement (cache_resource) et analyse par lots
+├── requirements.txt        # dépendances épinglées
+├── README.md                # ce fichier (en-tête YAML du Space)
+├── .streamlit/config.toml   # thème de l'application
+├── data/exemple_avis.csv    # jeu de démonstration (200 avis)
+├── data/generer_donnees.py  # script ayant généré le jeu de démonstration
+├── demo_rerun.py             # étape 1.1 — démo du rerun Streamlit
+└── demo_cache.py             # étape 1.2 — mesure du coût du cache
+```
+
+## Lancer en local
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+## Coût d'exécution observé
+
+*(à compléter après déploiement — voir rapport, questions 3, 6 et 11 : temps
+de build, temps de premier affichage, facteur d'accélération mesuré)*
+
+## Limites et biais
+
+À éprouver explicitement et documenter (voir rapport) :
+- **ironie** : « bravo pour les trois jours sans réseau, du grand art » — le
+  modèle de sentiment n'est pas entraîné pour détecter le second degré et
+  risque de classer ce type d'avis comme positif ou neutre.
+- **français mêlé de wolof** : « réseau bi dafa bon, merci beaucoup » — le
+  modèle traite le texte comme du français bruit ; les segments en wolof sont
+  ignorés ou mal tokenisés, ce qui peut dégrader le score de confiance.
+- **avis très courts** (« ok », « bof ») : peu de signal lexical, le modèle
+  est souvent moins confiant (score proche de 0,5) sur ces cas.
+
+## Comparaison avec le Space Gradio (TP9)
+
+Voir le rapport pour la comparaison argumentée sur les cinq axes : modèle
+d'exécution, gestion de l'état, mise en page, latence perçue, facilité de
+mise en production.
+
+## Secrets
+
+Si un modèle privé est utilisé, ajouter un `HF_TOKEN` dans *Settings →
+Variables and secrets* du Space et le lire via `os.environ["HF_TOKEN"]` —
+jamais en dur dans le code ni dans un `.streamlit/secrets.toml` versionné.

app.py

@@ -0,0 +1,270 @@
+"""
+Radar d'avis clients — TP13.
+
+Point d'entrée Streamlit. st.set_page_config DOIT être le premier appel
+Streamlit du script (sinon Streamlit lève une erreur).
+"""
+import datetime as dt
+import io
+
+import pandas as pd
+import streamlit as st
+
+from moteur import (
+    TAILLE_LOT,
+    analyser_sentiments,
+    charger_moteur,
+    detecter_themes,
+    evaluer_contre_verite_terrain,
+    resumer_avis_negatifs,
+)
+
+st.set_page_config(page_title="Radar d'avis clients", page_icon="📡", layout="wide")
+
+COLONNES_OBLIGATOIRES = {"id", "date", "avis"}
+CHEMIN_EXEMPLE = "data/exemple_avis.csv"
+THEMES_DISPONIBLES = ["réseau", "facturation", "service client", "application mobile", "prix"]
+
+
+# -----------------------------------------------------------------------------
+# Ingestion et nettoyage (étape 2.1) — mise en cache_data sur le CONTENU en
+# octets du fichier, jamais sur l'objet UploadedFile (qui n'est pas hashable
+# de façon stable d'un rerun à l'autre : la clé de cache changerait à chaque
+# exécution et le cache ne servirait jamais).
+# -----------------------------------------------------------------------------
+@st.cache_data(show_spinner=False)
+def charger_et_nettoyer(contenu_octets: bytes) -> pd.DataFrame:
+    df = pd.read_csv(io.BytesIO(contenu_octets), encoding="utf-8")
+    colonnes_manquantes = COLONNES_OBLIGATOIRES - set(df.columns)
+    if colonnes_manquantes:
+        raise ValueError(f"Colonnes manquantes : {', '.join(sorted(colonnes_manquantes))}")
+
+    df = df.dropna(subset=["avis"])
+    df["avis"] = df["avis"].astype(str).str.strip()
+    df = df[df["avis"] != ""]
+
+    n_avant = len(df)
+    doublons = df.duplicated(subset=["avis"]).sum()
+    df = df.drop_duplicates(subset=["avis"]).reset_index(drop=True)
+
+    if "date" in df.columns:
+        df["date"] = pd.to_datetime(df["date"], errors="coerce")
+
+    df.attrs["doublons_ecartes"] = int(doublons)
+    df.attrs["lignes_avant_nettoyage"] = n_avant
+    return df
+
+
+# -----------------------------------------------------------------------------
+# Barre latérale
+# -----------------------------------------------------------------------------
+st.sidebar.header("Paramètres")
+
+fichier_depose = st.sidebar.file_uploader("Déposer un CSV d'avis", type=["csv"])
+
+modele_sentiment_choisi = st.sidebar.selectbox(
+    "Modèle de sentiment",
+    ["cmarkea/distilcamembert-base-sentiment (par défaut)", "tblard/tf-allocine"],
+    help="Le second modèle n'est câblé qu'à titre d'exemple de choix dans moteur.py.",
+)
+
+themes_selectionnes = st.sidebar.multiselect(
+    "Thèmes à détecter", THEMES_DISPONIBLES, default=THEMES_DISPONIBLES
+)
+
+inclure_resume = st.sidebar.checkbox("Inclure le résumé (tête la plus lente)", value=False)
+
+# -----------------------------------------------------------------------------
+# Chargement du fichier (déposé ou exemple par défaut)
+# -----------------------------------------------------------------------------
+if fichier_depose is not None:
+    contenu = fichier_depose.getvalue()
+    nom_source = fichier_depose.name
+else:
+    with open(CHEMIN_EXEMPLE, "rb") as f:
+        contenu = f.read()
+    nom_source = CHEMIN_EXEMPLE
+    st.sidebar.info("Aucun fichier déposé — jeu de démonstration chargé automatiquement.")
+
+try:
+    df = charger_et_nettoyer(contenu)
+except ValueError as e:
+    st.error(f"Fichier invalide : {e}")
+    st.stop()
+except Exception as e:
+    st.error(f"Impossible de lire le fichier (encodage ou format incorrect) : {e}")
+    st.stop()
+
+if df.attrs.get("doublons_ecartes"):
+    st.sidebar.warning(f"{df.attrs['doublons_ecartes']} doublon(s) écarté(s).")
+
+nb_max = st.sidebar.slider("Nombre d'avis à analyser", 10, len(df), min(len(df), 100))
+
+st.title("📡 Radar d'avis clients")
+st.caption(f"Source : {nom_source} — {len(df)} avis valides après nettoyage")
+st.dataframe(df.head(10), width='stretch')
+
+lancer = st.sidebar.button("Lancer l'analyse", type="primary")
+
+if "historique" not in st.session_state:
+    st.session_state.historique = []
+if "resultats" not in st.session_state:
+    st.session_state.resultats = None
+
+# -----------------------------------------------------------------------------
+# Analyse (étape 2.2) — ne s'exécute qu'au clic sur "Lancer l'analyse", jamais
+# à chaque rerun déclenché par un simple changement de filtre d'affichage.
+# -----------------------------------------------------------------------------
+if lancer:
+    sous_df = df.head(nb_max).copy()
+    moteur = charger_moteur()
+
+    barre = st.progress(0.0, text="Analyse des sentiments...")
+    sentiments, n_tronques = analyser_sentiments(
+        moteur, sous_df["avis"].tolist(), progress_callback=lambda p: barre.progress(p, text="Analyse des sentiments...")
+    )
+    sous_df["sentiment"] = [r["label"] for r in sentiments]
+    sous_df["score"] = [round(r["score"], 3) for r in sentiments]
+
+    barre2 = st.progress(0.0, text="Détection des thèmes...")
+    if themes_selectionnes:
+        themes_resultats = detecter_themes(
+            moteur, sous_df["avis"].tolist(), themes_selectionnes,
+            progress_callback=lambda p: barre2.progress(p, text="Détection des thèmes..."),
+        )
+        sous_df["themes_detectes"] = [
+            ", ".join(l for l, s in zip(r["labels"], r["scores"]) if s >= 0.5) or "aucun"
+            for r in themes_resultats
+        ]
+    else:
+        sous_df["themes_detectes"] = "—"
+
+    resume_negatifs = ""
+    if inclure_resume:
+        with st.spinner("Génération du résumé des avis négatifs..."):
+            negatifs = sous_df.loc[sous_df["sentiment"] == "négatif", "avis"].tolist()
+            resume_negatifs = resumer_avis_negatifs(moteur, negatifs)
+
+    st.session_state.resultats = {
+        "df": sous_df,
+        "n_tronques": n_tronques,
+        "resume_negatifs": resume_negatifs,
+    }
+    st.session_state.historique.append(
+        {
+            "horodatage": dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "fichier": nom_source,
+            "n_avis": len(sous_df),
+            "part_positifs": round((sous_df["sentiment"] == "positif").mean() * 100, 1),
+        }
+    )
+
+# -----------------------------------------------------------------------------
+# Tableau de bord (étape 2.3)
+# -----------------------------------------------------------------------------
+if st.session_state.resultats is None:
+    st.info("Configurez les paramètres dans la barre latérale puis cliquez sur « Lancer l'analyse ».")
+    st.stop()
+
+res = st.session_state.resultats
+res_df = res["df"]
+
+a_verite_terrain = "note" in res_df.columns and res_df["note"].notna().any()
+noms_onglets = ["Synthèse", "Détail", "Historique"]
+if a_verite_terrain:
+    noms_onglets.insert(2, "Évaluation")
+onglets = st.tabs(noms_onglets)
+onglet_synthese, onglet_detail = onglets[0], onglets[1]
+if a_verite_terrain:
+    onglet_evaluation, onglet_historique = onglets[2], onglets[3]
+else:
+    onglet_historique = onglets[2]
+
+with onglet_synthese:
+    part_positifs = (res_df["sentiment"] == "positif").mean() * 100
+    score_moyen = res_df["score"].mean()
+    tous_themes = ", ".join(res_df["themes_detectes"]).split(", ")
+    tous_themes = [t for t in tous_themes if t not in ("aucun", "—", "")]
+    theme_dominant = pd.Series(tous_themes).mode().iat[0] if tous_themes else "N/A"
+
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Avis analysés", len(res_df), help="Nombre d'avis pris en compte dans cette analyse")
+    c2.metric("Part de positifs", f"{part_positifs:.1f} %", help="Proportion d'avis classés positifs")
+    c3.metric("Confiance moyenne", f"{score_moyen:.2f}", help="Score moyen du modèle de sentiment")
+    c4.metric("Thème dominant", theme_dominant, help="Thème le plus fréquemment détecté")
+
+    colg1, colg2 = st.columns(2)
+    with colg1:
+        st.subheader("Répartition des sentiments")
+        st.bar_chart(res_df["sentiment"].value_counts())
+    with colg2:
+        st.subheader("Thèmes les plus fréquents")
+        if tous_themes:
+            st.bar_chart(pd.Series(tous_themes).value_counts())
+        else:
+            st.caption("Aucun thème sélectionné.")
+
+    if "date" in res_df.columns and res_df["date"].notna().any():
+        st.subheader("Évolution hebdomadaire de la part d'avis négatifs")
+        tmp = res_df.dropna(subset=["date"]).set_index("date")
+        tmp["negatif"] = (tmp["sentiment"] == "négatif").astype(int)
+        hebdo = tmp["negatif"].resample("W").mean() * 100
+        st.line_chart(hebdo)
+
+    if res["resume_negatifs"]:
+        with st.expander("Résumé des avis négatifs"):
+            st.write(res["resume_negatifs"])
+
+with onglet_detail:
+    st.subheader("Détail des avis (trié par négativité)")
+    filtre_sentiment = st.multiselect("Filtrer par sentiment", res_df["sentiment"].unique().tolist())
+    filtre_theme = st.text_input("Filtrer par thème (contient)")
+
+    affiche = res_df.copy()
+    # Tri par score de négativité : on force les négatifs en tête via un score signé.
+    affiche["score_negativite"] = affiche.apply(
+        lambda r: r["score"] if r["sentiment"] == "négatif" else (0.5 if r["sentiment"] == "neutre" else 1 - r["score"]), axis=1
+    )
+    affiche = affiche.sort_values("score_negativite", ascending=False)
+
+    if filtre_sentiment:
+        affiche = affiche[affiche["sentiment"].isin(filtre_sentiment)]
+    if filtre_theme:
+        affiche = affiche[affiche["themes_detectes"].str.contains(filtre_theme, case=False, na=False)]
+
+    st.dataframe(
+        affiche[["avis", "sentiment", "score", "themes_detectes"]],
+        width='stretch',
+    )
+    st.download_button(
+        "Exporter le CSV enrichi",
+        data=affiche.to_csv(index=False).encode("utf-8"),
+        file_name="avis_enrichis.csv",
+        mime="text/csv",
+    )
+
+if a_verite_terrain:
+    with onglet_evaluation:
+        st.subheader("Accord avec la note client (question 7)")
+        st.caption("Binarisation : note ≤ 2 → négatif, note ≥ 4 → positif, note = 3 exclue (zone neutre ambiguë).")
+        evaluation = evaluer_contre_verite_terrain(res_df)
+        if evaluation is None:
+            st.info("Pas assez d'avis avec une note exploitable (hors note = 3) pour évaluer le modèle.")
+        else:
+            accuracy, f1, matrice = evaluation
+            c1, c2 = st.columns(2)
+            c1.metric("Accuracy", f"{accuracy:.2%}", help="Calculée avec evaluate.load('accuracy')")
+            c2.metric("F1-score", f"{f1:.2%}", help="Calculée avec evaluate.load('f1')")
+            st.subheader("Matrice de confusion")
+            st.dataframe(matrice, width="stretch")
+            st.caption(
+                "Erreurs les plus fréquentes attendues : avis ironiques (polarité lexicale positive, "
+                "sens réel négatif) et avis très courts (peu de signal, score proche de 0,5)."
+            )
+
+with onglet_historique:
+    st.subheader("Historique des analyses de cette session")
+    if st.session_state.historique:
+        st.dataframe(pd.DataFrame(st.session_state.historique), width='stretch')
+    else:
+        st.caption("Aucune analyse encore enregistrée.")

demo_cache.py

@@ -0,0 +1,98 @@
+"""
+Étape 1.2 — Mesurer le coût du cache sur un pipeline de sentiment français.
+
+Lancer avec : streamlit run demo_cache.py
+
+Protocole de mesure (voir rapport pour les chiffres retenus) :
+  1. Choisir une version dans la barre latérale (naïve / cache_resource / cache_data).
+  2. Saisir un texte, cliquer "Analyser" 20 fois de suite (N = 20 interactions).
+  3. Relever à chaque clic : temps de chargement, temps d'inférence.
+  4. Reporter temps total, temps moyen par interaction et facteur d'accélération
+     par rapport à la version naïve dans le tableau du rapport.
+
+Modèle utilisé : cmarkea/distilcamembert-base-sentiment (léger, adapté au CPU
+gratuit d'un Space).
+"""
+import time
+
+import streamlit as st
+from transformers import pipeline
+
+MODELE = "cmarkea/distilcamembert-base-sentiment"
+
+st.set_page_config(page_title="Démo cache", layout="centered")
+st.title("Démo — coût du cache sur un pipeline de sentiment")
+
+version = st.radio(
+    "Version à tester",
+    ["(a) naïve — sans cache", "(b) @st.cache_resource", "(c) @st.cache_resource + @st.cache_data"],
+)
+
+if "log" not in st.session_state:
+    st.session_state.log = []
+
+
+# --- (b) et (c) : le pipeline n'est chargé qu'une seule fois, partagé entre
+#     tous les utilisateurs de la session serveur -----------------------------
+@st.cache_resource(show_spinner=False)
+def charger_modele():
+    return pipeline("sentiment-analysis", model=MODELE, tokenizer=MODELE)
+
+
+# --- (c) uniquement : le RÉSULTAT (une valeur sérialisable : dict) est mis en
+#     cache pour un même texte -> deuxième appel quasi instantané -------------
+@st.cache_data(show_spinner=False)
+def analyser_cache(texte: str):
+    modele = charger_modele()
+    return modele(texte)[0]
+
+
+texte = st.text_area("Avis à analyser", "Le réseau est catastrophique depuis trois jours.")
+
+if st.button("Analyser"):
+    t0 = time.perf_counter()
+
+    if version.startswith("(a)"):
+        # (a) naïve : le pipeline est recréé (donc rechargé) à CHAQUE clic.
+        t_charge_debut = time.perf_counter()
+        modele = pipeline("sentiment-analysis", model=MODELE, tokenizer=MODELE)
+        t_chargement = time.perf_counter() - t_charge_debut
+
+        t_inf_debut = time.perf_counter()
+        resultat = modele(texte)[0]
+        t_inference = time.perf_counter() - t_inf_debut
+
+    elif version.startswith("(b)"):
+        t_charge_debut = time.perf_counter()
+        modele = charger_modele()  # quasi nul après le 1er appel (mis en cache_resource)
+        t_chargement = time.perf_counter() - t_charge_debut
+
+        t_inf_debut = time.perf_counter()
+        resultat = modele(texte)[0]
+        t_inference = time.perf_counter() - t_inf_debut
+
+    else:
+        t_charge_debut = time.perf_counter()
+        charger_modele()
+        t_chargement = time.perf_counter() - t_charge_debut
+
+        t_inf_debut = time.perf_counter()
+        resultat = analyser_cache(texte)  # quasi nul si texte déjà vu (cache_data)
+        t_inference = time.perf_counter() - t_inf_debut
+
+    total = time.perf_counter() - t0
+    st.session_state.log.append(
+        {
+            "version": version,
+            "chargement_s": round(t_chargement, 4),
+            "inference_s": round(t_inference, 4),
+            "total_s": round(total, 4),
+        }
+    )
+    st.write(resultat)
+
+if st.session_state.log:
+    st.subheader("Journal des interactions")
+    st.dataframe(st.session_state.log, width="stretch")
+    if st.button("Vider le journal"):
+        st.session_state.log = []

demo_rerun.py

@@ -0,0 +1,56 @@
+"""
+Étape 1.1 — Le rerun Streamlit et pourquoi une variable ordinaire ne survit pas.
+
+Lancer avec : streamlit run demo_rerun.py
+
+Observez :
+- le compteur "naïf" (variable Python ordinaire) reste bloqué à 1 après N clics,
+  car il est réinitialisé à 0 à chaque rerun, juste avant d'être incrémenté ;
+- le compteur stocké dans st.session_state s'incrémente correctement, car
+  session_state persiste entre les reruns (il est propre à un onglet/session) ;
+- l'horodatage en haut de page change à CHAQUE interaction, y compris une
+  simple frappe dans le champ prénom qui ne déclenche pourtant aucun clic sur
+  le bouton — preuve que Streamlit ré-exécute tout le script à chaque widget
+  qui change d'état, pas seulement au clic sur "Incrémenter".
+"""
+import datetime as dt
+
+import streamlit as st
+
+st.title("Démo — le rerun Streamlit")
+
+# Preuve visuelle du rerun : cette ligne s'affiche à CHAQUE exécution du script.
+st.write(f"Exécution du script à {dt.datetime.now().strftime('%H:%M:%S.%f')}")
+
+prenom = st.text_input("Votre prénom")
+
+st.divider()
+st.subheader("Compteur naïf (variable Python ordinaire)")
+
+# BUG VOLONTAIRE : cette variable est réinitialisée à 0 à chaque rerun,
+# donc quel que soit le nombre de clics, elle affichera toujours 1.
+compteur_naif = 0
+if st.button("Incrémenter (naïf)"):
+    compteur_naif += 1
+st.write(f"Valeur du compteur naïf : {compteur_naif}")
+
+st.divider()
+st.subheader("Compteur corrigé (st.session_state)")
+
+# Initialisation : la clé n'est créée QUE si elle n'existe pas déjà,
+# sinon on la remettrait à zéro à chaque rerun (même bug que ci-dessus).
+if "compteur" not in st.session_state:
+    st.session_state.compteur = 0
+
+col1, col2 = st.columns(2)
+with col1:
+    if st.button("Incrémenter (session_state)"):
+        st.session_state.compteur += 1
+with col2:
+    if st.button("Réinitialiser"):
+        st.session_state.compteur = 0
+
+st.write(f"Valeur du compteur en session_state : {st.session_state.compteur}")
+
+if prenom:
+    st.caption(f"Bonjour {prenom}, tape du texte ici pour déclencher un rerun sans cliquer sur aucun bouton.")

moteur.py

@@ -0,0 +1,170 @@
+"""
+Moteur d'analyse du Radar d'avis clients : trois têtes de modèle chargées
+une seule fois (via @st.cache_resource) et appelées par lots.
+
+Séparé de app.py pour que l'interface reste lisible et que le chargement
+des modèles soit testable indépendamment.
+"""
+import time
+
+import streamlit as st
+from transformers import pipeline
+
+MODELE_SENTIMENT = "cmarkea/distilcamembert-base-sentiment"
+MODELE_THEMES = "MoritzLaurer/mDeBERTa-v3-base-mnli-xnli"
+MODELE_RESUME = "plguillou/t5-base-fr-sum-cnndm"
+
+LONGUEUR_MAX_SENTIMENT = 512
+LONGUEUR_MAX_THEMES = 256
+TAILLE_LOT = 16
+
+
+@st.cache_resource(show_spinner="Chargement des modèles (une seule fois)...")
+def charger_moteur():
+    """Instancie les trois pipelines et les renvoie ensemble.
+
+    Objet non sérialisable -> @st.cache_resource (partagé, pas copié),
+    jamais @st.cache_data qui tenterait de sérialiser le modèle à chaque appel.
+    """
+    sentiment = pipeline(
+        "sentiment-analysis",
+        model=MODELE_SENTIMENT,
+        tokenizer=MODELE_SENTIMENT,
+        truncation=True,
+        max_length=LONGUEUR_MAX_SENTIMENT,
+    )
+    themes = pipeline("zero-shot-classification", model=MODELE_THEMES)
+    resume = pipeline("summarization", model=MODELE_RESUME, tokenizer=MODELE_RESUME)
+    return {"sentiment": sentiment, "themes": themes, "resume": resume}
+
+
+def _compter_tokens_tronques(textes, tokenizer, longueur_max):
+    """Renvoie le nombre de textes dont la tokenisation dépasse longueur_max
+    (donc effectivement tronqués par le pipeline)."""
+    n_tronques = 0
+    for t in textes:
+        ids = tokenizer(t, truncation=False)["input_ids"]
+        if len(ids) > longueur_max:
+            n_tronques += 1
+    return n_tronques
+
+
+def normaliser_sentiment(label_brut: str) -> str:
+    """cmarkea/distilcamembert-base-sentiment renvoie des labels du type
+    '1 star' .. '5 stars' (notation à la Amazon), pas directement
+    positif/négatif. On les ramène à trois classes, avec le même seuil que
+    la binarisation de la question 7 (<=2 négatif, ==3 neutre, >=4 positif).
+    """
+    n = int(label_brut.strip().split()[0])
+    if n <= 2:
+        return "négatif"
+    if n == 3:
+        return "neutre"
+    return "positif"
+
+
+def analyser_sentiments(moteur, avis, progress_callback=None):
+    """Classification de séquence par lots ; renvoie label + score de confiance."""
+    pipe = moteur["sentiment"]
+    n_tronques = _compter_tokens_tronques(avis, pipe.tokenizer, LONGUEUR_MAX_SENTIMENT)
+
+    resultats = []
+    n = len(avis)
+    for debut in range(0, n, TAILLE_LOT):
+        lot = avis[debut : debut + TAILLE_LOT]
+        sorties = pipe(lot, truncation=True, max_length=LONGUEUR_MAX_SENTIMENT, batch_size=TAILLE_LOT)
+        for s in sorties:
+            s["label_brut"] = s["label"]
+            s["label"] = normaliser_sentiment(s["label"])
+        resultats.extend(sorties)
+        if progress_callback:
+            progress_callback(min(debut + TAILLE_LOT, n) / n)
+    return resultats, n_tronques
+
+
+def detecter_themes(moteur, avis, themes_cibles, progress_callback=None):
+    """Zero-shot multi-étiquettes : un avis peut relever de plusieurs thèmes."""
+    pipe = moteur["themes"]
+    resultats = []
+    n = len(avis)
+    for debut in range(0, n, TAILLE_LOT):
+        lot = avis[debut : debut + TAILLE_LOT]
+        sorties = pipe(
+            lot,
+            candidate_labels=themes_cibles,
+            multi_label=True,
+            truncation=True,
+            max_length=LONGUEUR_MAX_THEMES,
+        )
+        # pipeline() renvoie un seul dict (pas une liste) si len(lot) == 1
+        if isinstance(sorties, dict):
+            sorties = [sorties]
+        resultats.extend(sorties)
+        if progress_callback:
+            progress_callback(min(debut + TAILLE_LOT, n) / n)
+    return resultats
+
+
+def resumer_avis_negatifs(moteur, avis_negatifs, longueur_max_source=800):
+    """Concatène les avis négatifs et produit un résumé en 3 lignes environ.
+    Tête la plus lente : à n'appeler que si la case "résumé" est cochée.
+    """
+    if not avis_negatifs:
+        return "Aucun avis négatif à résumer."
+    texte = " ".join(avis_negatifs)[:longueur_max_source]
+    pipe = moteur["resume"]
+    sortie = pipe(texte, truncation=True, max_length=120, min_length=30)
+    return sortie[0]["summary_text"]
+
+
+def chronometrer_sequentiel_vs_lots(moteur, avis):
+    """Utilitaire pour la question 6 : compare un traitement avis par avis
+    (boucle Python) à un traitement par lots de TAILLE_LOT."""
+    pipe = moteur["sentiment"]
+
+    t0 = time.perf_counter()
+    for a in avis:
+        pipe(a, truncation=True, max_length=LONGUEUR_MAX_SENTIMENT)
+    t_sequentiel = time.perf_counter() - t0
+
+    t0 = time.perf_counter()
+    for debut in range(0, len(avis), TAILLE_LOT):
+        lot = avis[debut : debut + TAILLE_LOT]
+        pipe(lot, truncation=True, max_length=LONGUEUR_MAX_SENTIMENT, batch_size=TAILLE_LOT)
+    t_lots = time.perf_counter() - t0
+
+    return t_sequentiel, t_lots
+
+
+def evaluer_contre_verite_terrain(df_resultats):
+    """Question 7 : binarise la colonne `note` (<=2 négatif, >=4 positif, 3
+    exclu) et calcule accuracy/F1 avec la bibliothèque `evaluate` (chapitre 5),
+    plutôt qu'un calcul manuel — API unifiée, cohérente avec le reste du cours.
+
+    Renvoie (accuracy, f1, matrice_confusion_dataframe) ou None si la colonne
+    `note` est absente ou si aucune ligne n'est exploitable après binarisation.
+    """
+    import evaluate
+    import pandas as pd
+
+    if "note" not in df_resultats.columns:
+        return None
+
+    df = df_resultats.dropna(subset=["note"]).copy()
+    df = df[df["note"] != 3]  # zone neutre ambiguë exclue de l'évaluation
+    if df.empty:
+        return None
+
+    df["reference"] = (df["note"] >= 4).astype(int)  # 1 = positif, 0 = négatif
+    df["prediction"] = (df["sentiment"] == "positif").astype(int)
+
+    metric_accuracy = evaluate.load("accuracy")
+    metric_f1 = evaluate.load("f1")
+    acc = metric_accuracy.compute(predictions=df["prediction"], references=df["reference"])["accuracy"]
+    f1 = metric_f1.compute(predictions=df["prediction"], references=df["reference"])["f1"]
+
+    matrice = pd.crosstab(
+        df["reference"].map({0: "Réel négatif", 1: "Réel positif"}),
+        df["prediction"].map({0: "Prédit négatif", 1: "Prédit positif"}),
+    )
+    return round(acc, 4), round(f1, 4), matrice

requirements.txt

@@ -0,0 +1,8 @@
+streamlit==1.62.0
+transformers==4.57.6
+torch==2.7.1
+pandas==2.2.3
+sentencepiece==0.2.0
+huggingface_hub==0.27.1
+evaluate==0.4.3
+scikit-learn==1.6.1