Addestramento di modelli sulle tue annotazioni

Novità nella v2.14.0

L'addestramento di modelli adatta un modello alle etichette che i tuoi annotatori hanno già assegnato, misura il modello su item esclusi dall'addestramento e può mostrare le risposte del modello agli annotatori come pre-etichette da confermare o correggere. Questa pagina spiega il ciclo di addestramento, la pagina Training dell'amministratore, i trainer raggruppati per compito e la pagina o il tutorial che tratta ogni parte nel dettaglio. La pagina è scritta per i responsabili di uno studio e per gli amministratori che gestiscono un server Potato in proprio. La pagina Training e il trainer sklearn-text fanno parte di Potato dalla versione 2.11. La versione 2.14.0 aggiunge 37 trainer, l'addestramento remoto su server GPU e cluster SLURM, i punteggi held-out nella tabella delle esecuzioni e la pubblicazione su Hugging Face Hub.

Il ciclo di addestramento

Ogni giro del ciclo addestra un modello sulle etichette umane raccolte finora e dà al prossimo annotatore le risposte del modello come punto di partenza. Il ciclo si svolge in sei passi:

1. Annota. Gli annotatori etichettano gli item come al solito, e Potato riduce a un'unica etichetta quelle di più annotatori sullo stesso item, con Dawid-Skene per impostazione predefinita oppure con un voto di maggioranza.
2. Addestra. Un'esecuzione divide gli item etichettati nelle partizioni train, val e test e adatta il modello in un processo separato. Ogni item resta nella stessa partizione da un'esecuzione all'altra, perché la partizione è un hash con seme dell'ID dell'item.
3. Valuta. L'esecuzione misura il modello sugli item val e test esclusi dall'addestramento.
4. Write-back. Le predizioni dell'esecuzione entrano nei dati di ogni item come pre-etichette per gli schemi che scegli. Le predizioni sotto una soglia minima di confidenza e quelle sugli item della partizione train restano escluse.
5. Correggi. Il prossimo annotatore vede già compilata la risposta del modello e la conferma o la cambia. Un revisore può anche registrare se il modello aveva ragione.
6. Riaddestra. L'esecuzione successiva si addestra sulle nuove etichette, e ogni item corretto da un revisore entra nella partizione train.

Attivare l'addestramento

L'addestramento di modelli è disattivato per impostazione predefinita, e una sola chiave di configurazione lo attiva. Aggiungi questo blocco a una configurazione esistente:

model_training:
  enabled: true

Riavvia il server e apri /admin/training con una sessione da amministratore o con la chiave API dell'amministratore. Senza enabled: true, le route dell'addestramento non esistono. Attivare l'addestramento non cambia nulla per gli annotatori, perché le pre-etichette compaiono solo per gli schemi elencati sotto writeback.schemas, e l'elenco è vuoto per impostazione predefinita.

Il pannello Start a run in cima alla pagina Training contiene tutta l'impostazione di un'esecuzione. Schema elenca gli schemi di annotazione dello studio, Trainer elenca i trainer adatti al tipo e agli item dello schema selezionato, e Runs on elenca i luoghi in cui un'esecuzione può girare. Il campo Parameters accetta JSON e parte dalla voce del trainer scelto in model_training.trainer_params. La nota sotto il campo indica ogni parametro che il trainer accetta. Train now avvia l'esecuzione. Un'esecuzione avviata mentre un'altra è in corso attende in una coda e compare nella tabella Runs come waiting #N, con un pulsante Cancel run.

Due esecuzioni di sklearn-text su uno schema di sentiment, ciascuna con un punteggio misurato su recensioni mai viste dal modello durante l'addestramento

Ogni ID nella tabella Runs apre la pagina dell'esecuzione in /admin/training/runs/<run_id>. La pagina mostra stato, trainer, backend, dimensioni delle partizioni, punteggio held-out e parametri dell'esecuzione, poi ogni metrica registrata e il log. Un'esecuzione fallita aggiunge una sezione What went wrong. Dalla pagina dell'esecuzione puoi anche salvare gli item val, test o train come versione del dataset e pubblicare il modello su Hugging Face Hub. Per una prima esecuzione completa su un progetto di esempio senza GPU, segui Addestra il tuo primo modello.

Trainer per compito

Potato 2.14.0 ha 38 trainer, ciascuno indicato nel menu Trainer con il nome del registro. La tabella raggruppa i trainer per il tipo di annotazione da cui ciascuno impara:

I cinque trainer dell'ultima riga non adattano nulla. Ciascuno invia gli item esclusi dall'addestramento a un modello che gira altrove, e Potato valuta, riscrive e fa rivedere le risposte come quelle di un modello addestrato. sklearn-text non richiede nulla oltre a una normale installazione di Potato, e pip install "potato-annotation[train]" installa ciò che serve ai trainer per testo, immagini, audio e LLM. Un trainer non installato compare nella pagina Training come "not installed", con il comando che lo installa. Trainer indica per ogni trainer i tipi di annotazione, i tipi di item, il comando di installazione e i parametri.

Dove girano le esecuzioni

Un'esecuzione gira su un backend, scelto per esecuzione nel menu Runs on oppure come impostazione predefinita con model_training.backend. Potato ha quattro tipi di backend:

• local addestra sul server Potato, in un sottoprocesso. device: auto sceglie prima CUDA, poi Metal di Apple, poi la CPU.
• ssh addestra su un server GPU che Potato raggiunge con ssh a chiave. Potato copia il codice sorgente di Potato sul server, avvia lì l'esecuzione e ricopia il modello dopo un'esecuzione riuscita.
• slurm si collega allo stesso modo al nodo di login di un cluster e invia il job di addestramento a un nodo di calcolo con sbatch. Il backend chiama solo sbatch, squeue, scancel e scontrol. Un cluster senza srun o sacct funziona quindi senza problemi.
• agent serve una macchina che Potato non può raggiungere, per esempio una workstation dietro NAT. potato training agent, eseguito su quella macchina, interroga il server in cerca di job, e i file del modello restano su quella macchina.

potato training check <backend> config.yaml verifica un backend prima della prima esecuzione, e il pulsante Check della pagina Training fa lo stesso. Configurazione elenca ogni chiave dei backend, e Addestrare su un server GPU o un cluster imposta passo per passo i tre tipi remoti.

Punteggi held-out

Ogni esecuzione misura il modello sugli item val e test, con una metrica scelta in base al tipo di annotazione dello schema. Un classificatore a etichetta singola ottiene il macro-F1, un tagger di span l'F1 sugli span, un detector di box la mAP a IoU 0.5 e un modello di trascrizione 1 meno il tasso di errore sulle parole. La tabella Runs mostra un punteggio principale per esecuzione, e la pagina dell'esecuzione elenca ogni metrica con la partizione nel nome della metrica, come val_macro_f1 o test_f1. Un item con un'etichetta e senza predizione conta come sbagliato. Un trainer non può quindi alzare il punteggio saltando gli item difficili. Quando un trainer sceglie il miglior checkpoint sugli item val, il punteggio principale viene dagli item test, perché il punteggio val ha già influenzato il modello. Un trainer che non sceglie nulla su val, come sklearn-text, prende il punteggio principale dagli item val. Configurazione indica le metriche di ogni tipo di annotazione.

Pre-etichette e coda di revisione del modello

Una pre-etichetta è la risposta di un modello già compilata nella pagina di annotazione, che l'annotatore conferma o cambia. Il write-back trasforma le predizioni di un'esecuzione in pre-etichette per gli schemi elencati sotto writeback.schemas, senza bisogno di un blocco pre_annotation. Aggiungi il blocco writeback sotto model_training:

model_training:
  enabled: true
  writeback:
    schemas: [sentiment]
    min_confidence: 0.6
    include_unlabeled: true

Con questo blocco, una predizione sentiment con confidenza inferiore a 0.6 viene salvata ma non mostrata. include_unlabeled: true fa predire a ogni esecuzione anche gli item che nessuno ha ancora etichettato. Senza questa impostazione, un'esecuzione predice solo sugli item val e test esclusi dall'addestramento. Gli item della partizione train di un'esecuzione non ricevono mai una pre-etichetta, e il write-back non modifica mai un'etichetta umana. Una pre-etichetta diventa la risposta dell'annotatore solo quando l'annotatore la modifica o passa all'item successivo.

Un nuovo annotatore vede selezionata la risposta del modello e la conferma o la cambia

assignment_strategy: model_review serve agli annotatori in revisione gli item pre-etichettati partendo da quelli con confidenza più bassa. Un revisore registra su ogni item un verdetto accept, correct o reject. Una pre-etichetta rifiutata viene tolta dall'item e non viene più mostrata. Ogni esecuzione successiva si addestra su un item con verdetto correct e non misura mai il modello su quell'item. Le pre-etichette spingono gli annotatori verso la risposta del modello. Attiva include_unlabeled quando il punteggio held-out giustifica il modello, e usa Come distinguere la revisione dall'approvazione automatica nei dati pre-etichettati per trovare gli annotatori che accettano le pre-etichette senza leggerle. Il modello nel ciclo percorre write-back, revisione e riaddestramento su un unico progetto.

Riaddestrare mentre arrivano le annotazioni

auto_retrain avvia le esecuzioni automaticamente man mano che arrivano le annotazioni, e ogni nuova esecuzione sostituisce le pre-etichette di quella precedente. Aggiungi il blocco sotto model_training:

model_training:
  enabled: true
  auto_retrain:
    enabled: true
    trainer: sklearn-text
    schemas: [sentiment]
    update_frequency: 25
    min_interval_s: 600

Con questi valori, un'esecuzione parte quando sono arrivate 25 annotazioni dall'ultima esecuzione automatica e sono passati 600 secondi dalla fine dell'ultima esecuzione. Configurazione elenca ogni chiave di auto_retrain e i motivi per cui un controllo salta un'esecuzione, e Il modello nel ciclo mostra quando attivare il riaddestramento.

Pubblicare un modello su Hugging Face Hub

Un'esecuzione riuscita il cui modello si trova sul server Potato ha nella pagina dell'esecuzione un modulo Publish to the Hugging Face Hub. Il push carica i pesi, la configurazione e i file del tokenizer del modello, più un README.md con la model card scritta a partire dall'esecuzione. La model card indica trainer, modello di base, schemi, etichette, dimensioni delle partizioni e punteggio held-out. Le predizioni dell'esecuzione e qualsiasi copia dei dati di addestramento restano sul server.

Digiti due volte il nome del repository, e il push procede solo se i due nomi coincidono. Private è selezionato per impostazione predefinita, e il token di Hugging Face viene da una variabile d'ambiente sul server (HF_TOKEN per impostazione predefinita) e non dalla pagina. Un modello rimasto su un host remoto o su una macchina agent non può essere pubblicato dalla pagina dell'esecuzione. Configurazione elenca quali file vengono caricati e la route API, e Fine-tuning di un LLM sulle tue annotazioni esegue un push dall'inizio alla fine.

Addestramento di modelli e motore di etichettatura

Il motore di etichettatura usa gli stessi trainer. Con la distillazione attiva (features.distill), il motore adatta un modello con un trainer (sklearn-text per impostazione predefinita) sulle etichette umane del motore e sulle etichette automatiche certificate da un contratto, poi mette il modello davanti alla cascata configurata come fonte trained. Gli item delle partizioni cert e audit del motore non entrano mai nel set di addestramento della distillazione. Una fonte trained può anche caricare un modello da un'esecuzione di addestramento, con la directory del modello dell'esecuzione come artifact_dir. Configurazione del motore di etichettatura elenca le chiavi della distillazione.

Addestramento di modelli e apprendimento attivo

La funzione di apprendimento attivo di Potato adatta un modello alle etichette dello studio per uno scopo più limitato dell'addestramento di modelli. L'apprendimento attivo adatta un classificatore scikit-learn dentro il processo del server ogni update_frequency annotazioni e lo usa per riordinare la coda, con gli item più incerti per primi. Gli annotatori ricevono la coda riordinata solo con assignment_strategy: active_learning. Il classificatore dell'apprendimento attivo viene valutato sugli item su cui è stato adattato, e le sue predizioni non vengono mai mostrate agli annotatori.

L'addestramento di modelli esegue uno qualsiasi dei 38 trainer in un processo separato o su un'altra macchina, misura il modello su item esclusi dall'addestramento e mostra le risposte del modello come pre-etichette. L'addestramento di modelli può anche ordinare la coda. Con assignment_strategy: llm_confidence, vengono per primi gli item la cui pre-etichetta pubblicata ha la confidenza più bassa. Il parametro acquisition di hf-text-classification e hf-image-classification sostituisce quell'ordine con un punteggio di margine, entropia, BALD o core-set. Usa l'apprendimento attivo per decidere quali item far etichettare dopo. Usa l'addestramento di modelli quando ti serve un modello valutato su item esclusi dall'addestramento, pre-etichette per gli annotatori o un modello da pubblicare.

Tutorial

Ogni tutorial percorre un'impostazione dall'installazione a un'esecuzione con punteggio:

• Addestra il tuo primo modello dalle tue annotazioni addestra sklearn-text su uno studio di sentiment, senza GPU.
• Addestrare su un server GPU, un cluster SLURM o una macchina dietro NAT imposta un server GPU ssh, un cluster SLURM e un agent che interroga il server.
• Etichettatura con il modello nel ciclo, con pre-etichette e riaddestramento tratta write-back, revisione, acquisizione, auto_retrain e versioni del dataset.
• Fine-tuning di un LLM sulle tue annotazioni addestra modelli SFT, DPO, di ricompensa e di ricompensa di processo, con QLoRA e un push su Hub.
• Addestra modelli di rilevamento e segmentazione sulle annotazioni di immagini addestra detector e segmentatori su immagini, vetrini, microscopia e mappe, più Cellpose, SAM, LayoutLMv3 e modelli visione-linguaggio.
• Addestra modelli per il parlato e l'audio sulle tue annotazioni addestra Whisper, la diarizzazione dei parlanti, detector su spettrogrammi e tagger audio, con file RTTM.
• Addestra modelli su volumi, nuvole di punti e video addestra volume-unet, external-3d e video-track.
• Addestra modelli su molecole, spettri, segnali ed episodi robotici addestra rdkit-property, peak-cnn, signal-cnn e episode-model.
• Pre-etichette e punteggi held-out da un modello che usi già collega un modello che servi già tramite un bridge di inferenza o label-studio-ml.
• Fine-tuning con privacy differenziale con Opacus addestra un classificatore con il parametro dp e Opacus.

Ulteriori letture

• Trainer - Tutti i 38 trainer, raggruppati per compito
• Configurazione - Ogni chiave model_training, backend, route e percorso di archiviazione
• Apprendimento attivo - Riordino della coda con un classificatore scikit-learn
• Pre-annotazione con LLM e modelli di visione - Pre-etichette da un LLM o da un modello di visione invece che da un modello addestrato
• Il motore di etichettatura - Etichette automatiche testate su un campione in cieco di etichette umane
• Simulatore di utenti - Annotatori simulati per provare il ciclo prima che inizino gli annotatori reali

Per i dettagli di implementazione, consulta la documentazione sorgente.