Potato 2.14: addestra modelli sulle tue annotazioni

Potato 2.14 addestra modelli sulle annotazioni di uno studio. Un'esecuzione adatta uno dei 38 trainer alle etichette date dagli annotatori, valuta il modello su item esclusi dall'addestramento e riscrive le predizioni del modello negli item come pre-etichette che gli annotatori confermano o correggono. La versione 2.13.1 aveva un solo trainer, sklearn-text. La release importa anche i file di diarizzazione RTTM, esporta i turni di parlato corretti, esegue WhisperX per la trascrizione locale e corregge diversi bug che modificavano i valori di accordo e le esportazioni, quindi leggi le note di aggiornamento prima di installare.

pip install --upgrade potato-annotation

Note di aggiornamento

Esegui prima potato validate config.yaml --strict su ogni configurazione. Le modifiche seguenti possono cambiare il comportamento di uno studio 2.13 funzionante:

• assignment_strategy: llm_confidence ora ordina la coda. La strategia serve per prima la pre-etichetta con confidenza più bassa, poi gli item senza pre-etichetta. Le release precedenti accettavano il valore e assegnavano gli item in modo casuale.
• model_training viene controllato in fase di validazione e all'avvio. Una chiave sconosciuta sotto writeback o auto_retrain, una partizione con un nome diverso da train, val o test e una voce di writeback.schemas che non è uno schema sono errori che fermano il server.
• La pagina Training riporta un punteggio held-out. La colonna del punteggio mostrava prima l'accuratezza sull'addestramento. Il punteggio di un'esecuzione 2.13 non è confrontabile con un punteggio held-out 2.14.
• Collegamenti, catene ed eventi compaiono nelle esportazioni. Le risposte span_link, coreference e event_annotation mancavano da ogni esportazione, e CSV e TSV ora aggiungono le colonne <scheme>._links e <scheme>._events.
• Potato non elenca più ujson in install_requires. Uno script tuo che importa ujson dall'ambiente di Potato richiede pip install ujson.

Addestramento di modelli

L'addestramento di modelli è pensato per uno studio con più item di quanti gli annotatori ne etichetteranno, dove un modello addestrato sulle prime etichette può proporre il resto. Il ciclo ha tre passi. Prima, un'esecuzione riduce le etichette di ogni item a una sola risposta e divide gli item in train, val e test. Poi, il trainer adatta un modello alla partizione train in un processo separato, e l'esecuzione valuta il modello sugli item val e test. Infine, il write-back mostra le predizioni del modello agli annotatori come pre-etichette, e le risposte che gli annotatori salvano diventano etichette per l'esecuzione successiva.

Per attivare il ciclo in uno studio con uno schema sentiment, aggiungi questo blocco alla configurazione dello studio:

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

Gli annotatori non vedono nulla di un'esecuzione finché uno schema non è indicato sotto writeback.schemas. include_unlabeled: true predice sugli item che nessuno ha etichettato, e min_confidence tiene fuori dalla pagina le predizioni sotto 0.6. Riavvia il server, apri /admin/training con la chiave dell'amministratore, scegli un trainer e uno schema e fai clic su Train now.

Il progetto di esempio di Potato in examples/ai-assisted/model-training/ ha 160 recensioni di prodotti ed esegue sklearn-text, che non richiede una GPU né nulla oltre a una normale installazione. La documentazione sull'addestramento di modelli riporta un'esecuzione lì, su 120 recensioni etichettate, che ha ottenuto 0.84 di macro-F1 sulle recensioni di validazione e ha scritto 80 pre-etichette. Un nuovo annotatore vede poi ciascuna di quelle recensioni con la risposta del modello già selezionata:

Addestra il tuo primo modello percorre l'esempio passo per passo.

Trainer per ogni tipo di annotazione

La pagina Training offre a ogni schema solo i trainer adatti allo schema. Il catalogo dei trainer elenca tutti i 38 trainer con i comandi di installazione, e l'elenco seguente indica i gruppi principali:

• Testo. hf-text-classification, setfit e sklearn-text classificano gli item. hf-token-classification etichetta gli span, hf-relation collega gli span in relazioni, eventi e catene di coreferenza, e byt5-gloss segmenta e glossa le parole per la glossatura interlineare.
• Immagini. torchvision-detect e ultralytics-detect addestrano detector, e torchvision-segment, ultralytics-segment e cellpose addestrano segmentatori. Le esecuzioni di rilevamento e segmentazione dividono in tile i vetrini interi e le immagini grandi e si addestrano su piani di microscopia e mappe GeoTIFF. volume-unet segmenta volumi 3D, layoutlmv3 etichetta i layout di pagina e vlm-sft esegue il fine-tuning di un modello visione-linguaggio su didascalie, grounding e passi della GUI.
• Audio e video. whisper-asr esegue il fine-tuning di Whisper sui turni di trascrizione corretti, diarization addestra un modello di parlanti sui turni di parlato, hf-audio-tagger etichetta segmenti audio e video-track segue gli oggetti tra i frame.
• LLM e agenti. llm-sft esegue il fine-tuning su risposte a testo libero, llm-dpo su preferenze a confronto, reward-model su risposte a confronto, classifiche e best-worst, e prm-reward su valutazioni dei passi di tracce di agenti.
• Scienza. rdkit-property predice risposte sulle molecole, peak-cnn predice le posizioni dei picchi negli spettri, signal-cnn etichetta intervalli di segnali di serie temporali e episode-model etichetta episodi robotici.

I trainer ultralytics sono AGPL-3.0, e i pesi di LayoutLMv3 sono CC BY-NC-SA 4.0. Un'esecuzione di uno dei due ti chiede prima di accettare la licenza. pip install "potato-annotation[train]" installa ciò che serve ai trainer per testo, immagini, audio e LLM, e il catalogo indica le installazioni separate.

Punteggi held-out e pre-etichette

Ogni esecuzione valuta le proprie predizioni sugli item val e test con una metrica adatta allo schema, come macro-F1 per le etichette, mAP50 per i box, tasso di errore sulle parole per le trascrizioni e Dice per i volumi. Un item con un'etichetta e senza predizione conta come sbagliato, e un valore di copertura riporta la quota di item che hanno ricevuto una predizione. Gli item della partizione train non ricevono mai una pre-etichetta, e un item corretto da un revisore finisce sempre nella partizione train delle esecuzioni successive.

Una pre-etichetta diventa la risposta dell'annotatore solo quando l'annotatore la modifica o passa oltre, e il write-back non modifica mai un'etichetta umana. La coda di revisione del modello serve le pre-etichette partendo da quelle con confidenza più bassa, e il report di revisione indica l'esecuzione dietro ogni pre-etichetta. Il modello nel ciclo tratta il flusso di revisione.

Addestrare su un server GPU o un cluster

Un'esecuzione gira su un backend. Il backend local si addestra sul server Potato e sceglie CUDA, Metal di Apple o la CPU. Un backend ssh avvia l'esecuzione su un server GPU che Potato può raggiungere e invia in streaming avanzamento e modello. Un backend slurm invia l'esecuzione a un nodo di calcolo con sbatch dal nodo di login e richiede solo sbatch, squeue e scancel. Un backend agent serve una macchina che Potato non può raggiungere, che esegue potato training agent e interroga il server in cerca di job. Prima di un'esecuzione su un backend ssh, potato training check <backend> config.yaml riporta il Python remoto, le GPU remote e i pacchetti di addestramento mancanti. Addestrare su un server GPU, un cluster SLURM o una macchina dietro NAT imposta ogni backend.

Scegliere che cosa chiedere dopo

hf-text-classification e hf-image-classification accettano un parametro acquisition che scrive un punteggio su ogni predizione, per margine, entropia, BALD o distanza core-set. assignment_strategy: llm_confidence serve poi per primo il punteggio più alto. auto_retrain avvia per impostazione predefinita una nuova esecuzione dopo ogni 25 nuove annotazioni, e ogni esecuzione rivaluta gli item non etichettati. Apprendimento attivo confronta questo ciclo con il blocco active_learning di Potato.

Modelli che hai già

Cinque trainer non adattano nulla e valutano un modello che gira altrove: label-studio-ml per un backend ML di Label Studio, openai-vlm-boxes per un modello visione-linguaggio dietro un'API compatibile con OpenAI, hf-inference per un Hugging Face Inference Endpoint, roboflow e cvat-nuclio per una funzione serverless di CVAT. Le predizioni di quei modelli ottengono lo stesso punteggio held-out, write-back e revisione di quelle di un modello addestrato. Pre-etichette e punteggi held-out da un modello che usi già tratta ogni bridge.

Pubblicare un modello

La pagina di un'esecuzione invia il modello a Hugging Face Hub con una model card che indica il trainer, il modello di base, gli schemi, le dimensioni delle partizioni e il punteggio held-out. Digiti due volte il nome del repository, il repository è privato per impostazione predefinita e il token viene da una variabile d'ambiente sul server. Le predizioni e i dati di addestramento restano sul server. La stessa pagina conserva la partizione di un'esecuzione e le sue etichette umane come versione del dataset, per confrontare modelli successivi sugli stessi item.

Trascrizioni, importazione ed esportazione

• WhisperX. potato transcripts --transcribe usa WhisperX quando è installato, con i tempi delle parole da un allineamento forzato con --asr-word-timestamps, e ripiega altrimenti su faster-whisper. Un'esecuzione whisper-asr scrive una copia CTranslate2 del modello con fine-tuning che --asr-model carica.
• Importazione RTTM. potato import -f rttm trasforma un file di diarizzazione, o una cartella di file di diarizzazione, in un item per registrazione con i turni di parlato da correggere. --speaker-map rinomina i parlanti.
• Esportazione segments. Il formato scrive una riga JSONL per ogni segmento audio o video e un file RTTM per annotatore.
• Dipendenze CoNLL-U. HEAD e DEPREL vengono da uno schema span_link orientato sugli span esportati. Entrambe le colonne erano sempre _ prima.

Correzioni che influiscono sui risultati

Il changelog elenca ogni correzione. Le correzioni seguenti potevano aver cambiato numeri che hai riportato:

• Un pareggio in una classifica scritto come B,D=A,C veniva letto come un unico item chiamato D=A, quindi il tau di Kendall e lo Spearman footrule escludevano entrambi gli item a pari merito.
• Le pre-etichette di slider, soft label e scala pairwise venivano salvate come risposta dell'annotatore al caricamento della pagina, quindi un item contava come completato prima che qualcuno rispondesse. Aprire un item grounding_eval lo salvava nello stesso modo.
• /admin/iaa elencava coreference, collegamenti tra span ed eventi come span senza punteggio. Il report ora valuta i tre tipi con l'F1 medio a coppie.
• Unire o dividere un codice nel codebook non reindirizzava alcuna codifica, perché nulla collegava le annotazioni salvate agli id dei codici.
• I manifest degli snapshot congelavano valori di accordo nulli, e ora registrano kappa e accordo percentuale.
• La revisione del modello contava un verdetto reject come un errore e non rispetto alla pre-etichetta che il verdetto aveva tolto, e la precisione del report di revisione risultava sbagliata. Una coppia annotatore-item esclusa manteneva inoltre il campo del write-back nei dati dell'item quando writeback.field era diverso da pre_annotation.field, e i dati dell'item per una coppia del genere ora escludono entrambi i campi.

Installare la 2.14

Aggiorna, valida ogni configurazione e installa i trainer che ti servono:

pip install --upgrade potato-annotation
potato validate config.yaml --strict
pip install "potato-annotation[train]"

Addestramento di modelli è il punto da cui partire, e Novità elenca il resto della release.