Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Qualità dei dati: pulizia e convalida

Lezione 4 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Perché la pulizia è fondamentale
  2. Convalida tecnica del file
  3. Pulizia dei contenuti
  4. Controlli di coerenza
  5. Utilizzo dell’API di convalida OpenAI
  6. Checklist pre-fine-tuning
  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 hanno mai eseguito un job di fine-tuning non possono più crearne uno; dal 2 luglio, devi aver utilizzato un modello sottoposto a fine-tuning 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 ritiro del loro modello base. Questo corso rimane utile per comprendere e sfruttare un modello esistente; per i nuovi progetti, dai priorità al prompt engineering, al RAG e alle valutazioni.

Perché la pulizia è fondamentale

Un file JSONL tecnicamente valido non garantisce un buon fine-tuning. Dati rumorosi, incoerenti o mal formattati degraderanno le prestazioni del modello invece di migliorarle, e la parte peggiore è che non genereranno alcun errore. Il job avrà successo, il modello sarà pronto e scoprirai il problema solo in produzione. Questa lezione copre le tecniche di pulizia e convalida che devi eseguire prima del caricamento.

Convalida tecnica del file

Inizia dalla meccanica: verifica che il tuo file sia sintatticamente corretto e che ogni riga rispetti il contratto previsto. La funzione seguente scorre il file riga per riga, accumulando gli errori invece di fermarsi al primo (vuoi l’elenco completo, non un avanti e indietro per ogni problema) e restituisce lungo il percorso alcune statistiche utili, come la presenza di messaggi di sistema e conversazioni multi-turno.

import json

def validate_jsonl(path: str) -> dict:
    """Validates a JSONL file and returns statistics."""
    errors = []
    stats = {"total": 0, "with_system": 0, "multi_turn": 0}
    valid_roles = {"system", "user", "assistant"}

    with open(path, "r", encoding="utf-8") as f:
        for i, line in enumerate(f, 1):
            stats["total"] += 1
            try:
                obj = json.loads(line.strip())
            except json.JSONDecodeError as e:
                errors.append(f"Line {i}: Invalid JSON — {e}")
                continue

            if "messages" not in obj:
                errors.append(f"Line {i}: Missing 'messages' key")
                continue

            messages = obj["messages"]
            if not isinstance(messages, list) or len(messages) < 2:
                errors.append(f"Line {i}: Minimum 2 messages required")
                continue

            for j, msg in enumerate(messages):
                role = msg.get("role")
                if role not in valid_roles:
                    errors.append(f"Line {i}, msg {j}: Invalid role")
                if not msg.get("content", "").strip():
                    errors.append(f"Line {i}, msg {j}: Empty content")

            if not any(m["role"] == "assistant" for m in messages):
                errors.append(f"Line {i}: No assistant message")

            if messages[0]["role"] == "system":
                stats["with_system"] += 1
            user_turns = sum(1 for m in messages if m["role"] == "user")
            if user_turns > 1:
                stats["multi_turn"] += 1

    return {"errors": errors, "stats": stats}

result = validate_jsonl("training_data.jsonl")
if result["errors"]:
    print(f"Errors: {len(result['errors'])}")
    for err in result["errors"][:10]:
        print(f"  - {err}")
else:
    print(f"File valid — {result['stats']['total']} examples")

Pulizia dei contenuti

Voci identiche o quasi duplicate distorcono l’addestramento sovrarappresentando certi schemi. Questo accade naturalmente quando aggreghi più esportazioni: la stessa domanda frequente appare trenta volte nei tuoi log e il modello conclude che merita trenta volte più attenzione delle altre. Un hash del contenuto concatenato dei messaggi è sufficiente per eliminarle.

import hashlib

def deduplicate(examples: list[dict]) -> list[dict]:
    """Removes duplicates based on message content."""
    seen = set()
    unique = []

    for ex in examples:
        content = "|".join(
            f"{m['role']}:{m['content']}" for m in ex["messages"]
        )
        h = hashlib.md5(content.encode()).hexdigest()

        if h not in seen:
            seen.add(h)
            unique.append(ex)

    print(f"Duplicates removed: {len(examples) - len(unique)}")
    return unique

Segue la normalizzazione del testo, che affronta quattro problemi distinti. Gli spazi multipli e le interruzioni di riga superflue, ereditate dal copia-incolla, devono sparire. La codifica deve essere normalizzata in UTF-8 con i caratteri di controllo rimossi: sono invisibili ma spesso presenti nelle esportazioni dai database. La punteggiatura merita un controllo: una risposta troncata a metà insegna al modello a interrompersi da solo. Infine, assicurati la coerenza linguistica: se desideri un registro formale, verifica che nessun esempio usi un registro informale, perché il modello riprodurrà fedelmente il mix.

import re
import unicodedata

def normalize_text(text: str) -> str:
    """Normalizes text for training."""
    text = unicodedata.normalize("NFC", text)
    text = re.sub(r"[\x00-\x09\x0b-\x0c\x0e-\x1f\x7f]", "", text)
    text = re.sub(r"[ \t]+", " ", text)
    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()

Controlli di coerenza

Se utilizzi un messaggio di sistema, questo deve essere rigorosamente identico in tutti i tuoi esempi. Due varianti che differiscono per una sola parola sono sufficienti a diluire il segnale: il modello smette di imparare un’istruzione specifica e inizia ad apprendere una famiglia sfocata di istruzioni. Il controllo è banale e il risultato è spesso sorprendente su un corpus costruito da più persone.

def check_system_messages(examples: list[dict]):
    """Checks consistency of system messages."""
    system_msgs = set()
    for ex in examples:
        for msg in ex["messages"]:
            if msg["role"] == "system":
                system_msgs.add(msg["content"].strip())

    if len(system_msgs) > 1:
        print(f"Warning: {len(system_msgs)} different system messages")
        for sm in system_msgs:
            print(f"  - {sm[:80]}...")
    elif len(system_msgs) == 1:
        print("System message consistent")
    else:
        print("No system message used")

La distribuzione delle lunghezze delle risposte racconta la stessa storia da un’altra angolazione. Risposte altamente eterogenee segnalano che più persone hanno scritto il corpus con idee diverse su cosa sia una buona risposta, o che un valore anomalo è scivolato nel batch. La soglia usata qui — un massimo superiore a cinque volte la media — non è assoluta, ma attira la tua attenzione nel punto giusto.

def analyze_lengths(examples: list[dict]):
    """Analyzes the distribution of response lengths."""
    lengths = []
    for ex in examples:
        for msg in ex["messages"]:
            if msg["role"] == "assistant":
                lengths.append(len(msg["content"]))

    if lengths:
        avg = sum(lengths) / len(lengths)
        mini, maxi = min(lengths), max(lengths)
        print(f"Response length — Avg: {avg:.0f} | Min: {mini} | Max: {maxi}")
        if maxi > avg * 5:
            print("High dispersion — check for outliers")

Utilizzo dell’API di convalida OpenAI

Una volta eseguiti i tuoi controlli, carica il file e lascia che anche OpenAI lo convalidi. È gratuito, immediato e ti evita di scoprire un problema di formato quando il job inizia.

from openai import OpenAI

client = OpenAI()

file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"File uploaded: {file.id}")
print(f"Status: {file.status}")

Se il file contiene errori, lo stato cambierà in error con un messaggio dettagliato. Correggi i problemi segnalati prima di riprovare.

Checklist pre-fine-tuning

Scorri questo elenco in ordine prima di creare il job: ogni voce corrisponde a un controllo trattato sopra, tranne l’ultima, che nessuno script può sostituire:

  • Il file JSONL è sintatticamente valido
  • Nessun duplicato
  • Testo normalizzato (UTF-8, spazi, punteggiatura)
  • Messaggi di sistema coerenti
  • Almeno 50 esempi (idealmente 100+)
  • Split train/validazione eseguito
  • Distribuzione ragionevole delle lunghezze
  • Revisione umana di un campione casuale

Punti chiave

  • Convalida sempre la sintassi JSONL prima del caricamento
  • Rimuovi i duplicati per evitare l’overfitting
  • La coerenza del messaggio di sistema è essenziale
  • Controlla la distribuzione delle lunghezze delle risposte
  • Fai revisionare un campione da un umano: è insostituibile