Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Test A/B e metriche aziendali

Lezione 12 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Oltre la Loss: misurare l’impatto sul business
  2. Configurare un test A/B
  3. Scegliere le metriche aziendali giuste
  4. Raccolta delle misurazioni
  5. Attendere la significatività statistica
  6. Scalare gradualmente
  7. Punti chiave

Aggiornamento 2 novembre 2026 — Disponibilità del fine-tuning. Il servizio di fine-tuning self-service di OpenAI sta venendo dismesso: dal 7 maggio 2026, le organizzazioni che non lo hanno mai utilizzato non possono più creare job; dal 2 luglio, devi aver usato un modello fine-tuned negli ultimi 60 giorni; e a partire dal 6 gennaio 2027, nessun cliente potrà avviare nuovi job. I modelli già addestrati rimangono utilizzabili fino al pensionamento del loro modello base. Questo corso resta utile per comprendere e sfruttare un modello esistente; per i nuovi progetti, dai priorità al prompt engineering, al RAG e alle valutazioni.

Oltre la Loss: misurare l’impatto sul business

La loss di addestramento e i punteggi di qualità non bastano. Ciò che conta davvero è l’impatto del tuo modello fine-tuned sulle tue KPI aziendali: soddisfazione del cliente, tempo di risoluzione, tasso di conversione. Un modello potrebbe generare risposte che i tuoi revisori trovano eleganti, aumentando contemporaneamente il tasso di escalations verso i tuoi agenti umani. È quel secondo numero a decidere il futuro del progetto, non il primo.

Configurare un test A/B

Un test A/B confronta due varianti in condizioni reali con traffico autentico. Il Gruppo A, o gruppo di controllo, riceve risposte dal modello base con il tuo prompt ottimizzato; il Gruppo B, o gruppo di test, ottiene risposte dal modello fine-tuned. Gli utenti vengono assegnati casualmente a entrambi i gruppi e misuri i risultati utilizzando le stesse metriche. L’intera validità dell’esercizio dipende da questa assegnazione: se al Gruppo B capitassero per caso le richieste più semplici, la sua apparente superiorità non misurerebbe altro che quella fortuna.

La funzione choisir_variante risolve questo problema hashando l’ID utente. Questo approccio garantisce che lo stesso utente veda sempre la stessa variante—essenziale, perché alternare tra le sessioni esporrebbe la persona a due stili di risposta, falsando il suo giudizio di soddisfazione. Produce una distribuzione statisticamente bilanciata una volta raggiunto un volume sufficiente e rimane riproducibile: rieseguire il calcolo in seguito genera esattamente gli stessi gruppi, permettendoti di ricalcolare una metrica dimenticata senza rilanciare il test.

import random
import hashlib
from openai import OpenAI

client = OpenAI()

MODELE_BASE = "gpt-5.6-luna"
MODELE_FT = "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
PROMPT_BASE = "You are a professional customer support assistant..."

def choisir_variante(user_id: str, pourcentage_test: int = 50) -> str:
    """Assigns a user to group A or B deterministically."""
    h = int(hashlib.md5(user_id.encode()).hexdigest(), 16)
    return "B" if (h % 100) < pourcentage_test else "A"

def repondre(user_id: str, question: str) -> dict:
    """Responds with the correct model based on the A/B group."""
    variante = choisir_variante(user_id)

    if variante == "A":
        response = client.responses.create(
            model=MODELE_BASE,
            instructions=PROMPT_BASE,
            input=question
        )
    else:
        response = client.responses.create(
            model=MODELE_FT,
            input=question
        )

    return {
        "variante": variante,
        "modele": MODELE_BASE if variante == "A" else MODELE_FT,
        "reponse": response.output_text,
        "user_id": user_id
    }

Scegliere le metriche aziendali giuste

Gli indicatori da monitorare dipendono interamente da ciò che il tuo assistente deve fornire, e ogni famiglia di casi d’uso ha i propri.

Per un servizio di assistenza clienti, il tasso di risoluzione al primo contatto risponde alla domanda più concreta: l’utente ha dovuto contattare di nuovo il supporto? Il punteggio CSAT, una valutazione di soddisfazione da 1 a 5 raccolta dopo l’interazione, cattura il sentiment che le metriche automatizzate perdono. Il tempo di risoluzione misura la durata totale dello scambio, e il tasso di escalation—la porzione di conversazioni trasferite a un umano—si legge come un’ammissione di fallimento del modello sui casi coinvolti. Un fine-tuning di successo tipicamente abbassa entrambi questi ultimi valori simultaneamente.

Per un chatbot di vendita, il ragionamento si sposta a valle. Il tasso di conversione conta le conversazioni che portano a un acquisto o a un appuntamento; il tasso di engagement, espresso come numero medio di messaggi per conversazione, richiede un’interpretazione attenta poiché uno scambio più lungo potrebbe segnalare sia interesse che incomprensione; il tasso di rimbalzo isola gli utenti che se ne vanno dopo il primo messaggio, spesso perché la risposta iniziale ha mancato il bersaglio.

Per un compito di classificazione o estrazione, torni alla triade classica. La precisione fornisce la percentuale di classificazioni corrette, il recall la percentuale di casi positivi effettivamente rilevati, e l’F1-score, la media armonica di entrambi, impedisce di accontentarsi di un modello che non predice mai la classe rara solo per evitare errori.

Raccolta delle misurazioni

Questi indicatori sono inutili se vivono in tre fogli di calcolo separati. Un singolo collettore, alimentato a ogni interazione, mantiene la variante insieme alla metrica e permette di produrre un report comparativo con un singolo comando. La classe ABTracker qui sotto svolge questo lavoro minimale: registra, poi raggruppa per variante e calcola medie e tassi.

import datetime

class ABTracker:
    """Metric collector for A/B testing."""

    def __init__(self):
        self.events = []

    def log_interaction(
        self,
        user_id: str,
        variante: str,
        question: str,
        reponse: str,
        metriques: dict
    ):
        """Records an interaction with its metrics."""
        self.events.append({
            "timestamp": datetime.datetime.now().isoformat(),
            "user_id": user_id,
            "variante": variante,
            "question": question,
            "reponse": reponse,
            **metriques
        })

    def rapport(self) -> dict:
        """Generates a comparative A vs B report."""
        groupes = {"A": [], "B": []}
        for e in self.events:
            groupes[e["variante"]].append(e)

        rapport = {}
        for variante, events in groupes.items():
            if not events:
                continue
            rapport[variante] = {
                "nb_interactions": len(events),
                "csat_moyen": self._moyenne(events, "csat"),
                "resolution_premier_contact": self._taux(events, "resolu"),
                "temps_moyen_sec": self._moyenne(events, "temps_resolution"),
            }

        return rapport

    def _moyenne(self, events, cle):
        vals = [e[cle] for e in events if cle in e and e[cle] is not None]
        return sum(vals) / len(vals) if vals else None

    def _taux(self, events, cle):
        vals = [e[cle] for e in events if cle in e]
        return sum(vals) / len(vals) * 100 if vals else None

tracker = ABTracker()

Attendere la significatività statistica

Non trarre conclusioni troppo presto. Dopo venti interazioni per gruppo, un divario di 0,4 punti nel CSAT non ha valore: bastano tre clienti felici per produrlo. Hai bisogno di abbastanza interazioni affinché i risultati siano significativi, e i benchmark qui sotto ti danno l’ordine di grandezza da raggiungere prima ancora di guardare i numeri.

100
Minimo per gruppo
500+
Per risultati affidabili
p < 0.05
Soglia di significatività

Una volta raggiunto quel volume, un test statistico decide per te. Il test di Mann-Whitney funziona bene per i punteggi di soddisfazione, che sono valutazioni ordinali raramente distribuite normalmente. Il suo p-value risponde a una domanda precisa: qual è la probabilità di osservare un divario così ampio se i due modelli fossero effettivamente uguali? Sotto 0,05, l’ipotesi del semplice caso diventa difficile da difendere.

from scipy import stats

def test_significativite(scores_a: list[float], scores_b: list[float]):
    """Tests whether the difference between A and B is significant."""
    stat, p_value = stats.mannwhitneyu(scores_a, scores_b, alternative="two-sided")

    moy_a = sum(scores_a) / len(scores_a)
    moy_b = sum(scores_b) / len(scores_b)

    print(f"Mean A: {moy_a:.3f}")
    print(f"Mean B: {moy_b:.3f}")
    print(f"p-value: {p_value:.4f}")

    if p_value < 0.05:
        gagnant = "B (fine-tuned)" if moy_b > moy_a else "A (base)"
        print(f"Significant difference — {gagnant} is better")
    else:
        print("No significant difference")

Scalare gradualmente

Anche un test di successo non giustifica il passaggio di tutto il traffico overnight: un difetto che appare solo una volta su mille rimane invisibile su un campione e diventa molto visibile a pieno volume. Procedi per fasi settimanali, controllando le tue metriche a ogni passo prima di aprire il successivo.

  1. Fase 1 (1 settimana): 10% di traffico sul modello fine-tuned
  2. Fase 2 (1 settimana): 30% se le metriche sono positive
  3. Fase 3 (1 settimana): 50% per il test A/B principale
  4. Fase 4: 100% se il test è conclusivo

Se una fase degrada le tue metriche, torna alla precedente invece di aprire la successiva sperando che il numero si riprenda da solo. Una settimana spesa a capire il perché costa sempre meno di un mese di traffico servito da un modello deludente.

Punti chiave

  • Le metriche aziendali contano più della loss di addestramento
  • Usa l’hashing deterministico per l’assegnazione A/B
  • Attendi la significatività statistica prima di concludere (p < 0,05)
  • Distribuisci gradualmente: 10%, 30%, 50%, 100%
  • Misura costi e latenza oltre alla qualità