Addestrare un modello sui dati di annotazione

Per addestrare un modello sui dati di annotazione, riduci le etichette di ogni item a un solo obiettivo o alla ripartizione dei voti degli annotatori, assegna gli item alle partizioni di addestramento, validazione e test con una regola che resti fissa tra un giro e l'altro e riporta il punteggio di test ogni volta che la partizione di validazione ha scelto il checkpoint. L'addestramento di modelli di Potato esegue ogni passo sulle annotazioni di uno studio e registra su quali item si è addestrata ogni esecuzione.

Novità nella v2.14.0

I dati di annotazione raramente arrivano nella forma che un trainer legge. Uno studio con sovrapposizione ha più etichette per item, e le etichette spesso sono in disaccordo. Uno studio ancora in corso guadagna etichette ogni giorno, e ogni giro di riaddestramento vede più item del giro precedente. Un trainer ha bisogno di un solo obiettivo per item e di un insieme fisso di item su cui valutare, e le decisioni qui sotto producono entrambi. Ogni sezione seguente nomina l'impostazione di Potato che prende la decisione. Per la pagina Training in sé, consulta la panoramica dell'addestramento di modelli e il tutorial che addestra un primo modello. Per addestrare invece nel tuo codice, Esportare le annotazioni per il machine learning tratta i formati di esportazione, e le stesse decisioni valgono per il file esportato.

Ridurre più annotatori a una sola etichetta

L'aggregazione trasforma le etichette che più annotatori hanno dato a un item nell'unica etichetta su cui si addestra un modello. Il metodo più semplice è il voto di maggioranza. Il voto di maggioranza conta una volta la risposta di ogni annotatore e tiene la risposta più comune. Dawid e Skene (1979) stimano con l'expectation-maximization una matrice di confusione per ciascun annotatore e pesano ogni voto in base all'affidabilità stimata dell'annotatore. Un annotatore disattento influenza allora il risultato meno di un annotatore attento. Aggregare le etichette del crowd confronta i due metodi e i modelli costruiti su Dawid-Skene.

Un'esecuzione di addestramento in Potato riduce le etichette con model_training.aggregation. Il valore predefinito, consensus, esegue Dawid-Skene ogni volta che il progetto ha più di un annotatore e ripiega sul voto di maggioranza se la stima fallisce. L'altro valore, majority, esegue solo il voto di maggioranza. Entrambi i metodi trattano l'intera risposta di un annotatore su uno schema come un solo voto. Due risposte multiselect contano quindi come lo stesso voto solo quando entrambe selezionano lo stesso insieme di etichette.

L'impostazione consensus dell'esecuzione e l'esportazione di consenso sono funzioni distinte. L'esportazione di consenso dà a ogni annotatore un voto, riporta il conteggio e la frazione di ogni risposta su ogni item e contrassegna ogni item come retired o needs_review. Leggi l'esportazione prima di addestrare quando vuoi vedere item per item dove gli annotatori si dividono. MACE stima un punteggio di competenza per ogni annotatore dagli stessi voti.

Imparare dal disaccordo

Nei compiti soggettivi come l'offensività o l'emozione, gli annotatori possono non essere d'accordo perché ciascuno legge l'item in modo diverso, e una sola etichetta decisa a voti scarta la divisione. Uma et al. (2021) passano in rassegna i metodi che si addestrano sul disaccordo invece che su un'unica etichetta aggregata. Una famiglia di questi metodi si addestra su soft label. Una soft label è una distribuzione di probabilità sulle etichette, costruita dalla quota di annotatori che ha scelto ciascuna etichetta.

hf-text-classification accetta il parametro soft_targets: true. Con il parametro impostato, un item che due o più annotatori hanno etichettato si addestra verso la ripartizione degli annotatori con la cross-entropy rispetto alla distribuzione. Quando due annotatori su tre hanno detto positive, l'obiettivo è 0,67 positive e 0,33 negative. Per uno schema multiselect, ogni etichetta si addestra verso la quota di annotatori che l'ha selezionata. Un item con un solo annotatore si addestra come prima sull'etichetta di quell'annotatore. Il modello resta allora incerto dove le persone erano in disaccordo, e ogni predizione include le probabilities del modello. Sugli item esclusi dall'addestramento con una ripartizione dei voti, l'esecuzione riporta tre ulteriori metriche:

In uno schema soft label, ogni annotatore dà una distribuzione con cursori. hf-text-classification addestra sempre uno schema soft_label verso la distribuzione media degli annotatori, e la pre-etichetta imposta i cursori sulla distribuzione predetta. Gli obiettivi soft richiedono due o più etichette su un item. Uno studio che prevede di addestrarsi sul disaccordo raccoglie quindi etichette sovrapposte fin dall'inizio, e Di quanti annotatori hai bisogno? tratta le impostazioni di sovrapposizione. Il disaccordo è un segnale, non rumore argomenta a favore del mantenere la divisione nei dati.

Partizioni di addestramento, validazione e test

Le partizioni di addestramento, validazione e test svolgono tre compiti diversi. La partizione di addestramento adatta i pesi del modello. La partizione di validazione sceglie tra modelli candidati, ad esempio l'epoca a cui fermarsi. La partizione di test stima le prestazioni su dati mai visti e non ha alcun ruolo in nessuna delle due scelte. Scegliere un checkpoint sulla validazione è una forma di adattamento alla validazione. Il checkpoint tenuto per il miglior punteggio di validazione ha un punteggio di validazione distorto verso l'alto, e solo il punteggio di test viene da item che la scelta non ha mai consultato.

Un'esecuzione di Potato divide per impostazione predefinita gli item etichettati in 70/15/15 (splits). La partizione di ogni item deriva da un hash con seme dell'ID dell'item (split_seed). Un item escluso dall'addestramento in un'esecuzione resta quindi escluso nella successiva, finché split_seed e splits restano invariati. Cambiare l'una o l'altra impostazione può spostare nell'addestramento item esclusi, e ogni punteggio successivo al cambiamento misura allora in parte la memorizzazione. Imposta entrambe una volta sola, all'inizio dello studio.

I trainer di fine-tuning, come hf-text-classification, tengono il checkpoint dell'epoca che ha ottenuto il punteggio migliore sulla validazione. Il punteggio principale di un'esecuzione simile viene da test. sklearn-text, setfit, rdkit-property, i trainer dei modelli decisionali e i bridge di inferenza non scelgono nulla sulla validazione, e un'esecuzione di uno di quei trainer prende il punteggio principale dalla validazione ogni volta che la validazione ha item. Il suggerimento della colonna Held-out score della tabella Runs nomina la partizione e la metrica dietro ogni numero. Un item con un'etichetta e senza predizione conta come sbagliato. Un trainer non può alzare il punteggio saltando gli item difficili, e <split>_coverage riporta la quota di item che hanno ricevuto una predizione.

Item corretti e fissati

Due tipi di item vanno nella partizione train di ogni esecuzione successiva, qualunque partizione l'hash abbia assegnato. Il primo è un item che un revisore ha corretto nella revisione del modello, e il secondo è un item che qualcuno ha fissato con Train on these accanto a una sezione nella pagina Catalog. Le correzioni vengono dagli item su cui il modello è andato peggio, e in validazione o test le correzioni valuterebbero il modello su un campione dei suoi stessi errori. Un'esecuzione che sposta item esclusi dall'addestramento nell'addestramento registra un avviso con il conteggio, e il punteggio held-out dell'esecuzione non è allora direttamente confrontabile con quello di un'esecuzione precedente. Anche un'esecuzione che si addestra su un item corretto che un'esecuzione precedente aveva escluso registra un avviso, perché un punteggio sugli item di validazione o test dell'esecuzione precedente, o su un dataset salvato da quegli item, include allora item su cui il nuovo modello si è addestrato. Le correzioni e gli item fissati si addestrano sempre indica le regole.

Registrare su che cosa si è addestrato ogni modello

Confrontare due esecuzioni richiede di sapere su quali item ogni esecuzione si è addestrata e ha valutato. Ogni esecuzione di Potato scrive un bundle sotto <output_annotation_dir>/training/runs/<run_id>/bundle/ con train.jsonl, val.jsonl, test.jsonl, labels.json e manifest.json. Il manifest registra il seme della partizione, il metodo di aggregazione, il numero di item di ogni partizione, il numero di item forzati nell'addestramento e un digest SHA-256 dei file delle partizioni. Nulla in un bundle rimanda a Potato, e uno script esterno a Potato può leggere il bundle come copia autonoma delle etichette risolte e delle partizioni.

Il database del progetto, project.sqlite, tiene un registro con una riga per esecuzione. Ogni riga registra il trainer, i parametri, le dimensioni delle partizioni, il seme della partizione, le metriche held-out e il digest del bundle. Una seconda tabella registra in quale partizione si trovava ogni item per ogni esecuzione. Il write-back legge quella tabella e non pre-etichetta mai un item su cui si è addestrata un'esecuzione ancora nel registro (retain_runs conserva per impostazione predefinita cinque esecuzioni concluse). Un modello è sicuro sugli item su cui si è addestrato, per ragioni che non dicono nulla sui dati nuovi.

Per confrontare modelli successivi esattamente sugli stessi item, Keep this split as a dataset nella pagina dell'esecuzione salva gli item di validazione, test o train dell'esecuzione come versione di un dataset, con le etichette umane concordate. Una versione salvata non cambia più. Ogni versione salvata contiene una sola partizione e parte da zero invece di aggiungersi alla versione precedente. Gli item di validazione dell'esecuzione 2 salvati sopra quelli dell'esecuzione 1 includerebbero altrimenti item su cui l'esecuzione 2 si è addestrata. Una valutazione su una versione salvata non può leggere la risposta del modello, perché gli input salvati escludono il campo delle pre-etichette. Il salvataggio richiede datasets.enabled: true. Quando il modello o il dataset lascia il progetto, Documentare dataset e modelli tratta le datasheet e le model card.

Di quanti dati ha bisogno un primo modello

Ogni trainer di Potato si rifiuta di eseguire l'adattamento con meno di min_instances item nella partizione train. I valori predefiniti seguenti sono i conteggi a cui parte un'esecuzione:

La soglia conta solo la partizione train. Con la partizione predefinita 70/15/15, un'esecuzione di sklearn-text parte quando circa 15 item hanno un'etichetta. L'esempio di addestramento di modelli nel repository di Potato fornisce un punto misurato. Con 120 delle 160 recensioni di prodotti sintetiche dell'esempio etichettate una volta ciascuna, un'esecuzione di sklearn-text ha ottenuto 0,84 di macro-F1 sulla validazione e ha pubblicato 80 pre-etichette. La cifra viene da un solo compito sintetico a due etichette, e il punteggio held-out delle tue esecuzioni è il numero da leggere per il tuo compito.

Inizia con sklearn-text. Il trainer non richiede nulla oltre a un'installazione semplice e nessuna GPU. Riaddestra man mano che arrivano le etichette, e osserva il punteggio held-out da un'esecuzione all'altra con split_seed invariato. Le pre-etichette ancorano gli annotatori. Lascia vuoto writeback.schemas finché il punteggio held-out non giustifica la visualizzazione delle risposte del modello. Etichettatura assistita dal modello tratta che cosa cambia quando gli annotatori vedono le pre-etichette, e Come distinguere la revisione dall'approvazione automatica tratta come verificare che gli annotatori leggano ancora gli item.

Una configurazione che imposta ogni decisione

La configurazione seguente si addestra su uno schema di sentiment a due etichette. Ogni chiave sotto model_training imposta una delle decisioni precedenti:

annotation_task_name: "Review sentiment"
task_dir: "."
data_files:
  - "data/reviews.json"
item_properties:
  id_key: "id"
  text_key: "text"
output_annotation_dir: "annotation_output"
 
annotation_schemes:
  - annotation_type: "radio"
    name: "sentiment"
    description: "Is this review positive or negative?"
    labels: ["positive", "negative"]
 
model_training:
  enabled: true
  aggregation: consensus
  split_seed: 0
  splits: {train: 0.7, val: 0.15, test: 0.15}
  trainer_params:
    hf-text-classification:
      soft_targets: true

aggregation: consensus riduce le etichette sovrapposte con Dawid-Skene. split_seed e splits sono scritti con i valori predefiniti perché nessuna delle due impostazioni dovrebbe cambiare per tutta la vita dello studio. soft_targets: true fa addestrare sulle ripartizioni dei voti ogni esecuzione di hf-text-classification sul progetto. Quel trainer richiede pip install "potato-annotation[train-text]", e sklearn-text funziona con la stessa configurazione senza installazioni aggiuntive. Senza un blocco writeback, gli annotatori non vedono pre-etichette. Riavvia il server con la configurazione, apri /admin/training, scegli un trainer e lo schema sentiment e fai clic su Train now. Il riferimento sulla configurazione dell'addestramento di modelli elenca ogni chiave, e il tutorial sul modello nel ciclo aggiunge il write-back e il riaddestramento automatico.

Ulteriori letture

• Panoramica dell'addestramento di modelli
• Addestra il tuo primo modello
• Etichettatura assistita dal modello
• Esportare le annotazioni per il machine learning
• Aggregare le etichette del crowd
• Accordo tra annotatori
• Riferimento sull'addestramento di modelli su GitHub, con le metriche held-out per ogni tipo di schema

Riferimenti

• Dawid, A. P., and Skene, A. M. (1979). Maximum Likelihood Estimation of Observer Error-Rates Using the EM Algorithm. Applied Statistics, 28(1), 20. doi.org/10.2307/2346806
• Uma, A. N., Fornaciari, T., Hovy, D., Paun, S., Plank, B., and Poesio, M. (2021). Learning from Disagreement: A Survey. Journal of Artificial Intelligence Research, 72, 1385–1470. doi.org/10.1613/jair.1.12752