Docker SDK + uv lockfile; load the SetFit pieces without setfit

gradio 6 requires transformers>=5, which setfit 1.1 cannot import. A SetFit
model is a SentenceTransformer plus a pickled logistic head, so app.py loads
those directly. Same 45/46 on the test split.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+.gradio/

.python-version

@@ -0,0 +1 @@
+3.12

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.12-slim
+COPY --from=ghcr.io/astral-sh/uv:0.8.13 /uv /uvx /bin/
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/app/.venv/bin:$PATH \
+    HF_HOME=/home/user/.cache/huggingface \
+    UV_LINK_MODE=copy \
+    UV_PYTHON_DOWNLOADS=never \
+    UV_NO_DEV=1
+
+WORKDIR $HOME/app
+
+COPY --chown=user pyproject.toml uv.lock ./
+RUN uv sync --locked
+
+COPY --chown=user app.py examples.json ./
+
+EXPOSE 7860
+CMD ["python", "app.py"]

README.md

@@ -3,10 +3,8 @@ title: Risque d'immobilisation
 emoji: 🔧
 colorFrom: red
 colorTo: gray
-sdk: gradio
-sdk_version: 6.20.0
-app_file: app.py
-python_version: "3.12"
+sdk: docker
+app_port: 7860
 short_description: Risque de panne depuis les tours de parole
 pinned: false
 ---
@@ -49,3 +47,21 @@ plainte elle-même sortirait de la fenêtre — le classifieur ne verrait plus q
 Le dépôt du modèle est privé. Le Space le lit via un secret `HF_TOKEN`
 (Settings → Secrets), qui doit avoir un accès en lecture à ce dépôt. Les secrets
 ne sont pas visibles par les visiteurs du Space.
+
+## Dépendances
+
+SDK Docker plutôt que Gradio, pour que les versions viennent d'un `uv.lock` :
+
+```
+uv sync        # environnement local, identique à celui de l'image
+uv lock        # après toute modification de pyproject.toml
+```
+
+`setfit` n'est pas installé. Un modèle SetFit est un `SentenceTransformer` suivi
+d'une régression logistique picklée, et `app.py` charge ces deux pièces
+directement — `gradio` 6 exige `transformers>=5`, que `setfit` 1.1 ne supporte
+pas (`ImportError: default_logdir`). Les deux chemins donnent les mêmes
+prédictions : 45/46 sur le split de test.
+
+`torch` vient de l'index CPU sur Linux, ce qui évite ~2 Go de CUDA inutile dans
+l'image.

app.py

@@ -1,103 +1,77 @@
-"""Breakdown-risk demo: does the caller's car still move?
-
-The model is the SetFit classifier `train.py` pushed -- a fine-tuned sentence
-encoder plus a logistic head -- and it decides between `risk` (the vehicle is
-probably immobilised, so the call needs a tow or an urgent slot) and `no_risk`
-(the customer can still drive, so a normal appointment will do).
-
-It reads the caller's turns and nothing else. In the live pipeline the agent's
-own replies are filtered out before the last three turns are taken, and this
-demo keeps that: one turn per line, only the last three reach the model. Slicing
-before filtering would spend the window on the agent's follow-up questions and
-push the complaint itself out of it.
-"""
-
 import json
 import os
 import time
 from pathlib import Path
 
 import gradio as gr
-import numpy as np
-from setfit import SetFitModel
+import joblib
+from huggingface_hub import hf_hub_download
+from sentence_transformers import SentenceTransformer
 
 MODEL_REPO = "bee2link/breakdown-risk-paraphrase-multilingual-MiniLM-L12-v2"
 DATASET_REPO = "bee2link/breakdown-risk"
-WINDOW = 3  # caller turns the classifier sees, matching `caller_turns`
+CALLER_TURNS = 3
+TOKEN = os.environ.get("HF_TOKEN")
+
+LABEL_NAMES = {"risk": "Risque de panne", "no_risk": "Pas de risque"}
+
+HEADER = f"""
+# Risque d'immobilisation
+
+Classe les **tours de parole de l'appelant** d'un appel entrant en `risk` — le
+véhicule est probablement immobilisé, il faut un dépannage ou un créneau urgent
+— ou `no_risk` — le client peut rouler, un rendez-vous normal suffit.
+
+<sub>SetFit · encodeur `paraphrase-multilingual-MiniLM-L12-v2` + tête logistique
+· entraîné sur [`{DATASET_REPO}`](https://huggingface.co/datasets/{DATASET_REPO})
+· 45/46 sur le split de test · seuls les {CALLER_TURNS} derniers tours sont
+lus</sub>
+"""
+
+PLACEHOLDER = "Oui bonjour.\nMa voiture ne démarre plus depuis ce matin."
 
-# The label the model returns -> what to call it on screen.
-DISPLAY = {
-    "risk": "Risque de panne",
-    "no_risk": "Pas de risque",
-}
 
-# The model repo is private, so the Space needs a token to read it. Set as a
-# Space secret, which is an environment variable here and is not exposed to
-# visitors.
-model = SetFitModel.from_pretrained(MODEL_REPO, token=os.environ.get("HF_TOKEN"))
-LABELS: list[str] = list(model.labels)
+def from_hub(filename: str) -> Path:
+    return Path(hf_hub_download(MODEL_REPO, filename, token=TOKEN))
 
+
+encoder = SentenceTransformer(MODEL_REPO, token=TOKEN)
+head = joblib.load(from_hub("model_head.pkl"))
+LABELS = json.loads(from_hub("config_setfit.json").read_text())["labels"]
 EXAMPLES = json.loads(Path("examples.json").read_text(encoding="utf-8"))
 
 
-def window(transcript: str) -> str:
-    """The last ``WINDOW`` non-empty lines: exactly what the tokenizer is handed."""
-    lines = [line.strip() for line in transcript.split("\n") if line.strip()]
-    return "\n".join(lines[-WINDOW:])
+def last_turns(transcript: str) -> list[str]:
+    lines = [line.strip() for line in transcript.splitlines() if line.strip()]
+    return lines[-CALLER_TURNS:]
 
 
-def classify(transcript: str) -> tuple[dict[str, float], str, str]:
-    """Score a caller's turns for breakdown risk.
+def score(text: str) -> dict[str, float]:
+    probabilities = head.predict_proba(encoder.encode([text]))[0]
+    return {LABEL_NAMES[name]: float(p) for name, p in zip(LABELS, probabilities)}
 
-    Args:
-        transcript: What the caller said, one turn per line. Only the last three
-            lines are classified; earlier ones are shown but ignored, the same
-            way the live pipeline windows a conversation.
 
-    Returns:
-        The probability per class, the text actually sent to the model, and a
-        one-line note on how long it took.
-    """
-    text = window(transcript)
-    if not text:
-        return {}, "", "*Saisissez au moins un tour de parole.*"
+def classify(transcript: str) -> tuple[dict[str, float], str, str]:
+    """Score a caller's turns for breakdown risk."""
+    turns = last_turns(transcript)
+    if not turns:
+        return {}, "", ""
 
+    text = "\n".join(turns)
     started = time.perf_counter()
-    probabilities = np.asarray(model.predict_proba([text])).reshape(-1)
-    elapsed = (time.perf_counter() - started) * 1000
-
-    scores = {DISPLAY.get(name, name): float(p) for name, p in zip(LABELS, probabilities)}
-    top = LABELS[int(probabilities.argmax())]
-    dropped = len([line for line in transcript.split("\n") if line.strip()]) - len(text.split("\n"))
-    note = f"`{top}` en {elapsed:.0f} ms"
-    if dropped > 0:
-        note += f" · {dropped} tour(s) plus ancien(s) hors fenêtre"
-    return scores, text, note
+    scores = score(text)
+    return scores, text, f"`{(time.perf_counter() - started) * 1000:.0f} ms`"
 
 
 with gr.Blocks(title="Risque d'immobilisation") as demo:
-    gr.Markdown(
-        f"""
-        # Risque d'immobilisation
-
-        Classe les **tours de parole de l'appelant** d'un appel entrant en
-        `risk` — le véhicule est probablement immobilisé, il faut un dépannage
-        ou un créneau urgent — ou `no_risk` — le client peut rouler, un
-        rendez-vous normal suffit.
-
-        <sub>SetFit (encodeur `paraphrase-multilingual-MiniLM-L12-v2` + tête
-        logistique) · entraîné sur [`{DATASET_REPO}`](https://huggingface.co/datasets/{DATASET_REPO})
-        · 45/46 sur le split de test · le modèle ne lit que les {WINDOW} derniers
-        tours</sub>
-        """
-    )
+    gr.Markdown(HEADER)
 
     with gr.Row():
         with gr.Column(scale=3):
             transcript = gr.Textbox(
                 label="Tours de parole de l'appelant",
-                info=f"Un tour par ligne. Seuls les {WINDOW} derniers sont classés.",
-                placeholder="Oui bonjour.\nMa voiture ne démarre plus depuis ce matin.",
+                info=f"Un tour par ligne. Seuls les {CALLER_TURNS} derniers sont classés.",
+                placeholder=PLACEHOLDER,
                 lines=7,
                 max_lines=14,
             )
@@ -105,34 +79,29 @@ with gr.Blocks(title="Risque d'immobilisation") as demo:
 
         with gr.Column(scale=2):
             prediction = gr.Label(label="Prédiction", num_top_classes=2)
-            sent = gr.Textbox(
+            window = gr.Textbox(
                 label="Ce que le modèle lit",
-                info=f"Les {WINDOW} derniers tours, tels qu'ils sont tokenisés.",
                 lines=3,
                 interactive=False,
                 buttons=["copy"],
             )
-            timing = gr.Markdown()
+            latency = gr.Markdown()
+
+    outputs = [prediction, window, latency]
 
     gr.Examples(
-        label="Exemples du split de test (jamais vus à l'entraînement)",
         examples=[[row["text"]] for row in EXAMPLES],
-        example_labels=[f"{DISPLAY[row['gold']]} — {row['id']}" for row in EXAMPLES],
-        inputs=[transcript],
-        outputs=[prediction, sent, timing],
+        example_labels=[f"{LABEL_NAMES[row['gold']]} — {row['id']}" for row in EXAMPLES],
+        label="Exemples du split de test",
+        inputs=transcript,
+        outputs=outputs,
         fn=classify,
         cache_examples=True,
         cache_mode="lazy",
     )
 
-    gr.on(
-        triggers=[run.click, transcript.submit],
-        fn=classify,
-        inputs=[transcript],
-        outputs=[prediction, sent, timing],
-        api_name="classify",
-    )
+    gr.on([run.click, transcript.submit], classify, transcript, outputs, api_name="classify")
 
 
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    demo.launch(server_name="0.0.0.0", server_port=7860)

pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "breakdown-risk-demo"
+version = "0.1.0"
+description = "Breakdown-risk classifier demo"
+readme = "README.md"
+requires-python = "==3.12.*"
+dependencies = [
+    "gradio==6.20.0",
+    "sentence-transformers>=5.6.1",
+    "scikit-learn>=1.5",
+    "joblib>=1.4",
+    "huggingface-hub>=0.30",
+    "torch>=2.2",
+    "numpy>=2",
+]
+
+[tool.uv]
+package = false
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[tool.uv.sources]
+torch = [{ index = "pytorch-cpu", marker = "sys_platform == 'linux'" }]

requirements.txt

@@ -1,10 +0,0 @@
-# CPU-only torch: the local version tag (+cpu) sorts above the PyPI wheel, so
-# pip takes it from here and the build skips ~2 GB of CUDA the Space cannot use.
---extra-index-url https://download.pytorch.org/whl/cpu
-torch
-# setfit 1.1 imports `default_logdir` from transformers.training_args, which
-# transformers 5 removed -- unpinned, the build resolves to 5.x and the Space
-# dies on `import setfit` before it ever reaches the model.
-transformers<5
-setfit>=1.1.0
-numpy