Upload 5 files

README.md

@@ -1,13 +1,15 @@
----
-title: Analyse Semantique NPS Assurance
-emoji: 🏆
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
-short_description: Un outil d'analyse sémantique cadré Net Promoter Score
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# NPS Assurance — Gradio UI
+## Installation rapide (Windows)
+```powershell
+python -m venv .venv; .\.venv\Scripts\Activate.ps1
+pip install -r requirements-min.txt
+python app_gradio_nps.py
+```
+## Option IA (OpenAI + HF)
+```powershell
+pip install -r requirements-full.txt
+# clé : setx OPENAI_API_KEY "ta_cle"
+python app_gradio_nps.py
+```
+## CSV attendu
+- colonnes : `comment`, `nps_score`, `id` (optionnel)

app_gradio_nps.py

@@ -0,0 +1,423 @@
+# -*- coding: utf-8 -*-
+"""
+Gradio UI — Analyse sémantique NPS (Assurance)
+- Sentiment : OpenAI -> HuggingFace -> Règles (OpenAI désactivé par défaut)
+- Thèmes : Regex (+ option OpenAI) + occurrences
+- Résumé : synthèse chiffrée (+ option synthèse OpenAI)
+- UI : tableaux consultables + 3 panneaux (Enchantements/Irritants/Recos)
+- Graphiques : NPS (jauge), Emotions (barres), Top thèmes (barres), Balance Pos/Neg (stacked)
+Lancer : python app_gradio_nps.py
+"""
+
+import os, re, json, collections, tempfile, zipfile
+from typing import List, Dict, Optional
+import pandas as pd
+from unidecode import unidecode
+import gradio as gr
+import plotly.express as px
+import plotly.graph_objects as go
+
+# ---------- Thésaurus ASSURANCE ----------
+THEMES = {
+    "Remboursements santé":[r"\bremboursement[s]?\b", r"\bt[eé]l[eé]transmission\b", r"\bno[eé]mie\b",
+        r"\bprise\s*en\s*charge[s]?\b", r"\btaux\s+de\s+remboursement[s]?\b", r"\b(ameli|cpam)\b",
+        r"\bcompl[eé]mentaire\s+sant[eé]\b", r"\bmutuelle\b", r"\battestation[s]?\b", r"\bcarte\s+(mutuelle|tiers\s*payant)\b"],
+    "Tiers payant / Réseau de soins":[r"\btiers\s*payant\b", r"\br[ée]seau[x]?\s+de\s+soins\b",
+        r"\b(optique|dentaire|hospitalisation|pharmacie)\b", r"\bitelis\b", r"\bsant[eé]clair\b", r"\bkalixia\b"],
+    "Sinistres / Indemnisation":[r"\bsinistre[s]?\b", r"\bindemni(sation|ser)\b", r"\bexpertis[ea]\b",
+        r"\bd[eé]claration\s+de\s+sinistre\b", r"\bconstat\b", r"\bbris\s+de\s+glace\b", r"\bassistance\b", r"\bd[ée]pannage\b"],
+    "Adhésion / Contrat":[r"\badh[eé]sion[s]?\b", r"\bsouscription[s]?\b", r"\baffiliation[s]?\b", r"\bcontrat[s]?\b",
+        r"\bavenant[s]?\b", r"\bcarence[s]?\b", r"\brenouvellement[s]?\b", r"\br[eé]siliation[s]?\b"],
+    "Garanties / Exclusions / Franchise":[r"\bgarantie[s]?\b", r"\bexclusion[s]?\b", r"\bplafond[s]?\b",
+        r"\bfranchise[s]?\b", r"\bconditions\s+g[eé]n[eé]rales\b", r"\bnotice\b"],
+    "Cotisations / Facturation":[r"\bcotisation[s]?\b", r"\bpr[eé]l[eè]vement[s]?\b", r"\bech[eé]ancier[s]?\b",
+        r"\bfacture[s]?\b", r"\berreur[s]?\s+de\s+facturation\b", r"\bremboursement[s]?\b", r"\bRIB\b", r"\bIBAN\b"],
+    "Délais & Suivi dossier":[r"\bd[eé]lai[s]?\b", r"\btraitement[s]?\b", r"\bsuivi[s]?\b", r"\brelance[s]?\b", r"\bretard[s]?\b"],
+    "Espace client / App / Connexion":[r"\bespace\s+client\b", r"\bapplication\b", r"\bapp\b", r"\bsite\b",
+        r"\bconnexion\b", r"\bidentifiant[s]?\b", r"\bmot\s+de\s+passe\b", r"\bpaiement\s+en\s+ligne\b",
+        r"\bbogue[s]?\b", r"\bbug[s]?\b", r"\bnavigation\b", r"\binterface\b", r"\bUX\b"],
+    "Support / Conseiller":[r"\bSAV\b", r"\bservice[s]?\s+client[s]?\b", r"\bconseiller[s]?\b",
+        r"\b[rR][eé]ponse[s]?\b", r"\bjoignable[s]?\b", r"\brapp?el\b"],
+    "Communication / Transparence":[r"\binformation[s]?\b", r"\bcommunication\b", r"\btransparence\b",
+        r"\bclart[eé]\b", r"\bcourrier[s]?\b", r"\bmail[s]?\b", r"\bnotification[s]?\b"],
+    "Prix":[r"\bprix\b", r"\bcher[s]?\b", r"\bco[uû]t[s]?\b", r"\btarif[s]?\b",
+        r"\bcomp[eé]titif[s]?\b", r"\babusif[s]?\b", r"\bbon\s+rapport\s+qualit[eé]\s*prix\b"],
+    "Offre / Gamme":[r"\boffre[s]?\b", r"\bgamme[s]?\b", r"\bdisponibilit[eé][s]?\b", r"\bdevis\b", r"\bchoix\b", r"\bcatalogue[s]?\b"],
+    "Produit/Qualité":[r"\bqualit[eé]s?\b", r"\bfiable[s]?\b", r"\bconforme[s]?\b", r"\bnon\s+conforme[s]?\b",
+        r"\bd[eé]fectueux?[es]?\b", r"\bperformant[e]?[s]?\b"],
+    "Agence / Accueil":[r"\bagence[s]?\b", r"\bboutique[s]?\b", r"\baccueil\b", r"\bconseil[s]?\b", r"\battente\b", r"\bcaisse[s]?\b"],
+}
+
+# ---------- Fallback sentiment ----------
+POS_WORDS = {"bien":1.0,"super":1.2,"parfait":1.4,"excellent":1.5,"ravi":1.2,"ravis":1.2,"satisfait":1.0,"satisfaite":1.0,
+             "rapide":0.8,"efficace":1.0,"fiable":1.0,"simple":0.8,"facile":0.8,"clair":0.8,"conforme":0.8,"sympa":0.8,
+             "professionnel":1.0,"réactif":1.0,"reactif":1.0,"compétent":1.0,"competent":1.0,"top":1.2,"recommande":1.2,
+             "recommandé":1.2,"bon":0.8,"fiers":1.0}
+NEG_WORDS = {"mauvais":-1.2,"horrible":-1.5,"naze":-1.0,"nul":-1.2,"lente":-0.8,"lent":-0.8,"cher":-0.9,"arnaque":-1.5,
+             "déçu":-1.2,"decu":-1.2,"incompétent":-1.3,"incompetent":-1.3,"bug":-0.9,"bogue":-0.9,"problème":-1.0,
+             "probleme":-1.0,"attente":-0.6,"retard":-0.9,"erreur":-1.0,"mensonge":-1.4,"complexe":-0.7,"compliqué":-0.8,
+             "complique":-0.8,"défectueux":-1.3,"defectueux":-1.3,"non conforme":-1.2,"impossible":-1.0,"difficile":-0.7}
+NEGATIONS = [r"\bpas\b", r"\bjamais\b", r"\bplus\b", r"\baucun[e]?\b", r"\brien\b", r"\bni\b", r"\bgu[eè]re\b"]
+INTENSIFIERS = [r"\btr[eè]s\b", r"\bvraiment\b", r"\btellement\b", r"\bextr[eê]mement\b", r"\bhyper\b"]
+DIMINISHERS  = [r"\bun[e]?\s+peu\b", r"\bassez\b", r"\bplut[oô]t\b", r"\bl[eé]g[eè]rement\b"]
+INTENSIFIER_W, DIMINISHER_W = 1.5, 0.7
+
+# ---------- OpenAI (optionnel) ----------
+OPENAI_AVAILABLE = False
+try:
+    from openai import OpenAI
+    _client = OpenAI()  # clé via OPENAI_API_KEY
+    OPENAI_AVAILABLE = True
+except Exception:
+    OPENAI_AVAILABLE = False
+
+# ---------- Utils ----------
+def normalize(t:str)->str:
+    if not isinstance(t,str): return ""
+    return re.sub(r"\s+"," ",t.strip())
+
+def to_analyzable(t:str)->str:
+    return unidecode(normalize(t.lower()))
+
+def window_has(patterns:List[str], toks:List[str], i:int, w:int=3)->bool:
+    s=max(0,i-w); e=min(len(toks),i+w+1); win=" ".join(toks[s:e])
+    return any(re.search(p,win) for p in patterns)
+
+def lexical_sentiment_score(text:str)->float:
+    toks = to_analyzable(text).split(); score=0.0
+    for i,t in enumerate(toks):
+        base = POS_WORDS.get(t,0.0) or NEG_WORDS.get(t,0.0)
+        if not base and i<len(toks)-1:
+            bi=f"{t} {toks[i+1]}"; base = NEG_WORDS.get(bi,0.0)
+        if base:
+            w=1.0
+            if window_has(INTENSIFIERS,toks,i): w*=INTENSIFIER_W
+            if window_has(DIMINISHERS,toks,i):  w*=DIMINISHER_W
+            if window_has(NEGATIONS,toks,i):    base*=-1
+            score+=base*w
+    return max(min(score,4.0),-4.0)
+
+def lexical_sentiment_label(s:float)->str:
+    return "positive" if s>=0.3 else ("negatif" if s<=-0.3 else "neutre")
+
+def detect_themes_regex(text:str):
+    t=to_analyzable(text); found=[]; counts={}
+    for th,pats in THEMES.items():
+        c=sum(len(re.findall(p,t)) for p in pats)
+        if c>0: found.append(th); counts[th]=c
+    return found, counts
+
+def nps_bucket(s):
+    try: s=int(s)
+    except: return "inconnu"
+    return "promoter" if s>=9 else ("passive" if s>=7 else ("detractor" if s>=0 else "inconnu"))
+
+def compute_nps(series):
+    vals=[]
+    for x in series.dropna().tolist():
+        try:
+            v=int(x)
+            if 0<=v<=10: vals.append(v)
+        except: pass
+    if not vals: return None
+    tot=len(vals); pro=sum(1 for v in vals if v>=9); det=sum(1 for v in vals if v<=6)
+    return 100.0*(pro/tot - det/tot)
+
+def anonymize(t:str)->str:
+    if not isinstance(t,str): return ""
+    t=re.sub(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}","[email]",t)
+    t=re.sub(r"\b(?:\+?\d[\s.-]?){7,}\b","[tel]",t)
+    return t
+
+# ---------- OpenAI helpers ----------
+def openai_json(model:str, system:str, user:str, temperature:float=0.0) -> Optional[dict]:
+    if not OPENAI_AVAILABLE: return None
+    try:
+        resp = _client.chat.completions.create(
+            model=model, temperature=temperature,
+            messages=[{"role":"system","content":system},{"role":"user","content":user}],
+        )
+        txt = resp.choices[0].message.content.strip()
+        m = re.search(r"\{.*\}", txt, re.S)
+        return json.loads(m.group(0) if m else txt)
+    except Exception:
+        return None
+
+def oa_sentiment(comment:str, model:str, temperature:float=0.0) -> Optional[dict]:
+    system = "Tu es un classifieur FR. Réponds strictement en JSON."
+    user = f'Texte: {comment}\nDonne "label" parmi ["positive","neutre","negatif"] et "score" entre -4 et 4. JSON.'
+    return openai_json(model, system, user, temperature)
+
+def oa_themes(comment:str, model:str, temperature:float=0.0) -> Optional[dict]:
+    system = "Tu maps le texte client vers un thésaurus assurance. Réponds strictement en JSON."
+    user = f"Texte: {comment}\nThésaurus: {json.dumps(list(THEMES.keys()), ensure_ascii=False)}\nRetourne {{'themes': [...], 'counts': {{...}}}}"
+    return openai_json(model, system, user, temperature)
+
+def oa_summary(nps:Optional[float], dist:Dict[str,int], themes_df:pd.DataFrame, model:str, temperature:float=0.2) -> Optional[str]:
+    system = "Tu es un analyste CX FR. Donne une synthèse courte et actionnable en Markdown."
+    top = [] if themes_df is None else themes_df.head(6).to_dict(orient="records")
+    user = f"Données: NPS={None if nps is None else round(nps,1)}, Répartition={dist}, Thèmes={json.dumps(top, ensure_ascii=False)}"
+    j = openai_json(model, system, user, temperature)
+    if isinstance(j, dict) and "text" in j: return j["text"]
+    if isinstance(j, dict): return ' '.join(str(v) for v in j.values())
+    return None
+
+# ---------- Recos & panneaux ----------
+RECO_RULES = {
+    "Délais & Suivi dossier": "Réduire les délais (SLA), suivi proactif, file d’attente priorisée.",
+    "Cotisations / Facturation": "Audit prélèvements, factures claires, alertes anomalies, parcours litige.",
+    "Espace client / App / Connexion": "Corriger login/MDP, parcours réinitialisation, QA multi-navigateurs.",
+    "Support / Conseiller": "Améliorer joignabilité, formation, scripts d’appel, rappel auto.",
+    "Communication / Transparence": "Messages clairs, notifications aux étapes clés, FAQ ciblées.",
+    "Sinistres / Indemnisation": "Transparence étapes/délais, suivi dossier, points de contact dédiés.",
+    "Remboursements santé": "Accélérer télétransmission, notifier réception/prise en charge.",
+    "Tiers payant / Réseau de soins": "Élargir réseau, informer disponibilité, carte à jour.",
+    "Garanties / Exclusions / Franchise": "Clarifier CG, simulateur de reste à charge, exemples.",
+}
+def make_panels(themes_df: pd.DataFrame):
+    if themes_df is None or themes_df.empty: return "—","—","—"
+    pos_top = themes_df.sort_values(["verbatims_pos","total_mentions"], ascending=[False,False]).head(4)
+    neg_top = themes_df.sort_values(["verbatims_neg","total_mentions"], ascending=[False,False]).head(4)
+    def bullets(df, col, label):
+        lines=[f"**{label}**"]
+        for _, r in df.iterrows(): lines.append(f"- **{r['theme']}** — {int(r[col])} verbatims")
+        return "\n".join(lines)
+    ench_md = bullets(pos_top, "verbatims_pos", "Points d’enchantement")
+    irr_md  = bullets(neg_top, "verbatims_neg", "Irritants")
+    rec_lines=["**Recommandations**"]
+    for _, r in neg_top.iterrows():
+        rec_lines.append(f"- **{r['theme']}** — {RECO_RULES.get(r['theme'],'Analyser les causes racines et plan d’action.')}")
+    return ench_md, irr_md, "\n".join(rec_lines)
+
+# ---------- Graphiques Plotly ----------
+def fig_nps_gauge(nps: Optional[float]) -> go.Figure:
+    v = 0.0 if nps is None else float(nps)
+    return go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=v,
+        gauge={"axis":{"range":[-100,100]}, "bar":{"thickness":0.3}},
+        title={"text":"NPS (−100 à +100)"}
+    ))
+
+def fig_sentiment_bar(dist: Dict[str,int]) -> go.Figure:
+    order = ["negatif","neutre","positive"]
+    x = [o for o in order if o in dist]
+    y = [dist.get(o,0) for o in x]
+    return px.bar(x=x, y=y, labels={"x":"Sentiment","y":"Nombre"}, title="Répartition des émotions")
+
+def fig_top_themes(themes_df: pd.DataFrame, k: int) -> go.Figure:
+    if themes_df is None or themes_df.empty: return go.Figure()
+    d = themes_df.head(k)
+    fig = px.bar(d, x="theme", y="total_mentions", title=f"Top {k} thèmes — occurrences")
+    fig.update_layout(xaxis_tickangle=-30)
+    return fig
+
+def fig_theme_balance(themes_df: pd.DataFrame, k: int) -> go.Figure:
+    if themes_df is None or themes_df.empty: return go.Figure()
+    d = themes_df.head(k)
+    d2 = d.melt(id_vars=["theme"], value_vars=["verbatims_pos","verbatims_neg"], var_name="type", value_name="count")
+    d2["type"] = d2["type"].map({"verbatims_pos":"Positifs","verbatims_neg":"Négatifs"})
+    fig = px.bar(d2, x="theme", y="count", color="type", barmode="stack", title=f"Top {k} thèmes — balance Pos/Neg")
+    fig.update_layout(xaxis_tickangle=-30)
+    return fig
+
+# ---------- Analyse principale ----------
+def analyze_file(file_obj, comment_col, score_col, id_col,
+                 do_anonymize,
+                 use_oa_sent, use_oa_themes, use_oa_summary,
+                 oa_model, oa_temp,
+                 top_k):
+
+    # Lecture CSV
+    try:
+        df=pd.read_csv(file_obj.name, sep=None, engine="python")
+    except Exception:
+        df=pd.read_csv(file_obj.name)
+
+    # Remap auto
+    rem={"verbatim":"comment","texte":"comment","avis":"comment","note":"nps_score","score":"nps_score",
+         "Identifiant":"id","identifiant":"id","id_client":"id"}
+    df=df.rename(columns={k:v for k,v in rem.items() if k in df.columns})
+
+    # Overrides UI
+    if comment_col and comment_col in df.columns and comment_col!="comment": df=df.rename(columns={comment_col:"comment"})
+    if score_col and score_col in df.columns and score_col!="nps_score":     df=df.rename(columns={score_col:"nps_score"})
+    if id_col and id_col in df.columns and id_col!="id":                     df=df.rename(columns={id_col:"id"})
+
+    if "comment" not in df.columns: raise gr.Error("Colonne 'comment' introuvable.")
+    if "nps_score" not in df.columns: raise gr.Error("Colonne 'nps_score' introuvable.")
+    if "id" not in df.columns: df["id"]=range(1,len(df)+1)
+    if do_anonymize: df["comment"]=df["comment"].apply(anonymize)
+
+    if (use_oa_sent or use_oa_themes or use_oa_summary) and not OPENAI_AVAILABLE:
+        raise gr.Error("OpenAI non dispo (installe `openai` et définis OPENAI_API_KEY).")
+
+    # Init HF lazy
+    HF_AVAILABLE=False
+    try:
+        from transformers import pipeline
+        hf_pipe = pipeline("text-classification",
+                           model="cmarkea/distilcamembert-base-sentiment",
+                           tokenizer="cmarkea/distilcamembert-base-sentiment")
+        HF_AVAILABLE=True
+    except Exception:
+        HF_AVAILABLE=False
+
+    def hf_sent(text:str):
+        if not HF_AVAILABLE or not text.strip(): return None
+        try:
+            res=hf_pipe(text); lab=str(res[0]["label"]).lower(); p=float(res[0].get("score",0.5))
+            if "1" in lab or "2" in lab: return {"label":"negatif","score":-4*p}
+            if "3" in lab:               return {"label":"neutre","score":0.0}
+            return {"label":"positive","score":4*p}
+        except Exception:
+            return None
+
+    rows=[]
+    theme_agg=collections.defaultdict(lambda:{"mentions":0,"pos":0,"neg":0})
+    used_hf=False; used_oa=False
+
+    for _, r in df.iterrows():
+        cid=r["id"]; comment=normalize(str(r["comment"]))
+
+        # Sentiment: OpenAI -> HF -> règles
+        sent=None
+        if use_oa_sent:
+            sent=oa_sentiment(comment, oa_model, oa_temp); used_oa = used_oa or bool(sent)
+        if not sent:
+            hf=hf_sent(comment)
+            if hf: sent=hf; used_hf=True
+        if not sent:
+            s=float(lexical_sentiment_score(comment))
+            sent={"label":lexical_sentiment_label(s),"score":s}
+
+        # Thèmes : regex (+ fusion OA)
+        themes, counts = detect_themes_regex(comment)
+        if use_oa_themes:
+            tjson=oa_themes(comment, oa_model, oa_temp)
+            if isinstance(tjson, dict):
+                used_oa=True
+                for th, c in (tjson.get("counts",{}) or {}).items():
+                    if th in THEMES and int(c) > 0:
+                        counts[th] = max(counts.get(th, 0), int(c))
+                themes = [th for th, c in counts.items() if c > 0]
+
+        bucket = nps_bucket(r.get("nps_score", None))
+
+        for th, c in counts.items():
+            theme_agg[th]["mentions"] += c
+            if sent["label"] == "positive":
+                theme_agg[th]["pos"] += 1
+            elif sent["label"] == "negatif":
+                theme_agg[th]["neg"] += 1
+
+        rows.append({
+            "id": cid, "nps_score": r.get("nps_score", None), "nps_bucket": bucket,
+            "comment": comment,
+            "sentiment_score": round(float(sent["score"]), 3),
+            "sentiment_label": sent["label"],
+            "sentiment_source": "openai" if (use_oa_sent and used_oa) else ("huggingface" if used_hf else "rules"),
+            "themes": ", ".join(themes) if themes else "",
+            "theme_counts_json": json.dumps(counts, ensure_ascii=False)
+        })
+
+    out_df=pd.DataFrame(rows)
+    nps=compute_nps(df["nps_score"])
+    dist=out_df["sentiment_label"].value_counts().to_dict()
+
+    # Stats par thème
+    trs=[]
+    for th, d in theme_agg.items():
+        trs.append({"theme":th,"total_mentions":int(d["mentions"]),
+                    "verbatims_pos":int(d["pos"]),"verbatims_neg":int(d["neg"]),
+                    "net_sentiment":int(d["pos"]-d["neg"])})
+    themes_df=pd.DataFrame(trs).sort_values(["total_mentions","net_sentiment"],ascending=[False,False])
+
+    # Synthèse texte
+    method = "OpenAI + HF + règles" if (use_oa_sent and used_hf) else ("OpenAI + règles" if use_oa_sent else ("HF + règles" if used_hf else "Règles"))
+    lines=[ "# Synthèse NPS & ressentis clients",
+            f"- **Méthode** : {method}",
+            f"- **NPS global** : {nps:.1f}" if nps is not None else "- **NPS global** : n/a" ]
+    if dist:
+        tot=sum(dist.values()); pos=dist.get("positive",0); neg=dist.get("negatif",0); neu=dist.get("neutre",0)
+        lines.append(f"- **Répartition émotions** : positive {pos}/{tot}, neutre {neu}/{tot}, négative {neg}/{tot}")
+    if not themes_df.empty:
+        lines.append("\n## Thèmes les plus cités")
+        for th,m in themes_df.head(5)[["theme","total_mentions"]].values.tolist():
+            lines.append(f"- **{th}** : {m} occurrence(s)")
+    summary_md="\n".join(lines)
+
+    # Synthèse OpenAI optionnelle
+    if use_oa_summary:
+        md = oa_summary(nps, dist, themes_df, oa_model, oa_temp)
+        if md: summary_md = md + "\n\n---\n" + summary_md
+
+    # Fichiers
+    tmpdir=tempfile.mkdtemp(prefix="nps_gradio_")
+    enriched=os.path.join(tmpdir,"enriched_comments.csv"); themes=os.path.join(tmpdir,"themes_stats.csv"); summ=os.path.join(tmpdir,"summary.md")
+    out_df.to_csv(enriched,index=False,encoding="utf-8-sig")
+    themes_df.to_csv(themes,index=False,encoding="utf-8-sig")
+    with open(summ,"w",encoding="utf-8") as f: f.write(summary_md)
+    zip_path=os.path.join(tmpdir,"nps_outputs.zip")
+    with zipfile.ZipFile(zip_path,"w",zipfile.ZIP_DEFLATED) as z:
+        z.write(enriched,arcname="enriched_comments.csv"); z.write(themes,arcname="themes_stats.csv"); z.write(summ,arcname="summary.md")
+
+    # Graphiques
+    fig_gauge = fig_nps_gauge(nps)
+    fig_emots = fig_sentiment_bar(dist)
+    k = max(1, int(top_k or 10))
+    fig_top   = fig_top_themes(themes_df, k)
+    fig_bal   = fig_theme_balance(themes_df, k)
+
+    return (summary_md, themes_df.head(100), out_df.head(200), [enriched, themes, summ, zip_path],
+            fig_gauge, fig_emots, fig_top, fig_bal)
+
+# ---------- UI ----------
+with gr.Blocks(title="Analyse NPS — Assurance") as demo:
+    gr.Markdown("## 🔎 Analyse sémantique NPS — Assurance\nTéléverse un CSV, mappe les colonnes, options OpenAI (facultatives), puis lance.")
+
+    with gr.Row():
+        csv_in=gr.File(label="CSV NPS (UTF-8)", file_types=[".csv"], type="filepath")
+        with gr.Column():
+            ccol=gr.Textbox(label="Colonne 'comment' (laisser vide si déjà 'comment')", placeholder="ex: verbatim / texte")
+            scol=gr.Textbox(label="Colonne 'nps_score' (laisser vide si déjà 'nps_score')", placeholder="ex: note / score")
+            icol=gr.Textbox(label="Colonne 'id' (optionnel)", placeholder="ex: identifiant")
+
+    with gr.Row():
+        anon=gr.Checkbox(label="Anonymiser emails / téléphones", value=True)
+        # OpenAI désactivé par défaut pour éviter les erreurs de clé
+        use_oa_sent=gr.Checkbox(label="OpenAI pour le sentiment", value=False)
+        use_oa_themes=gr.Checkbox(label="OpenAI pour les thèmes", value=False)
+        use_oa_summary=gr.Checkbox(label="OpenAI pour la synthèse", value=False)
+
+    with gr.Row():
+        oa_model=gr.Textbox(label="Modèle OpenAI", value="gpt-4o-mini")
+        oa_temp=gr.Slider(label="Température", minimum=0.0, maximum=1.0, value=0.1, step=0.1)
+        top_k=gr.Slider(label="Top thèmes (K) pour les graphes", minimum=5, maximum=20, value=10, step=1)
+        run=gr.Button("Lancer l'analyse", variant="primary")
+
+    summary=gr.Markdown(label="Synthèse")
+    themes_table=gr.Dataframe(label="Thèmes — statistiques")
+    enriched_table=gr.Dataframe(label="Verbatims enrichis (aperçu)")
+    files_out=gr.Files(label="Téléchargements (CSV & ZIP)")
+
+    with gr.Row():
+        plot_nps = gr.Plot(label="NPS — Jauge")
+        plot_sent= gr.Plot(label="Répartition des émotions")
+    with gr.Row():
+        plot_top  = gr.Plot(label="Top thèmes — occurrences")
+        plot_bal  = gr.Plot(label="Top thèmes — balance Pos/Neg")
+
+    def _go(file,cc,sc,ic,a,uos,uot,uosum,model,temp,k):
+        if file is None: raise gr.Error("Ajoute un CSV.")
+        class F: pass
+        f=F(); f.name = file if isinstance(file,str) else file.name
+        return analyze_file(f, cc.strip() if cc else "", sc.strip() if sc else "", ic.strip() if ic else "",
+                            a, uos, uot, uosum, model.strip() or "gpt-4o-mini", float(temp or 0.0), int(k or 10))
+
+    run.click(_go,
+              inputs=[csv_in, ccol, scol, icol, anon, use_oa_sent, use_oa_themes, use_oa_summary, oa_model, oa_temp, top_k],
+              outputs=[summary, themes_table, enriched_table, files_out, plot_nps, plot_sent, plot_top, plot_bal])
+
+if __name__=="__main__":
+    demo.launch(share=False, show_api=False)

nps_comments_sample_assurance.csv

@@ -0,0 +1,5 @@
+id,nps_score,comment
+1,10,"Remboursement rapide, télétransmission OK, je recommande."
+2,6,"Impossible de joindre un conseiller, retard de traitement du dossier."
+3,9,"Tiers payant nickel chez l'opticien, parcours simple."
+4,5,"Erreur de facturation et prélèvements doublés, très déçu."

requirements-full.txt

@@ -0,0 +1,7 @@
+gradio
+pandas
+unidecode
+plotly
+openai
+transformers
+torch

requirements-min.txt

@@ -0,0 +1,4 @@
+gradio
+pandas
+unidecode
+plotly