Condividi tramite

Interpretazione di epoch_size, minibatch_size_in_samples e MinibatchSource.next_minibatch in CNTK

  • Articolo

In questo articolo verranno chiarite l'interpretazione e l'utilizzo dei parametri e delle funzioni seguenti in Python:

epoch_size

Numero di esempi di etichette (tensori lungo un asse dinamico) in ogni epoca. In epoch_size CNTK è il numero di esempi di etichette dopo cui vengono eseguite azioni aggiuntive specifiche, tra cui

  • salvataggio di un modello di checkpoint (il training può essere riavviato da qui)
  • convalida incrociata
  • controllo della frequenza di apprendimento
  • minibatch-scaling

Si noti che la definizione del numero di esempi di etichette è simile al numero di campioni usati per minibatch_size_in_samples. La definizione di differisce dalla definizione di epoch_sizeminibatch_size_in_samples nel senso che epoch_size è esempi di etichette , non esempi di input.

Quindi, importante, per i dati sequenziali, un esempio è un singolo elemento di una sequenza. Di conseguenza, CNTK epoch_sizenon fa riferimento a un numero di sequenze, ma il numero di elementi di sequenza tra leetichette della sequenza che costituiscono il minibatch.

Altrettanto importante, epoch_size si riferisce agli esempi di etichetta , non agli esempi di input e al numero di etichette per sequenza non è necessariamente il numero di esempi di input. È possibile, ad esempio, disporre di un'etichetta per sequenza e per ogni sequenza di avere molti campioni (in tal caso agisce come il numero di sequenze) e è possibile avere un'etichetta per ogni esempio in una sequenza, in cui in questo caso epoch_sizeepoch_size viene eseguito esattamente come minibatch_size_in_samples in tale esempio (non sequenza) viene conteggiato.

Per dimensioni più piccole del set di dati, epoch_size spesso è impostato uguale alla dimensione del set di dati. In Python è possibile specificare cntk.io.INFINITELY_REPEAT per questo. In Python è anche possibile impostarlo su cntk.io.FULL_DATA_SWEEP, in cui l'elaborazione si arresterà dopo un passaggio dell'intera dimensione dei dati.

Per set di dati di grandi dimensioni, è possibile guidare la scelta per epoch_size il checkpoint. Ad esempio, se si desidera perdere al massimo 30 minuti di calcolo in caso di interruzione di alimentazione o di interruzione della rete, si vuole creare un checkpoint circa ogni 30 minuti (da cui è possibile riprendere il training). Scegliere epoch_size di essere il numero di campioni che richiedono circa 30 minuti per il calcolo.

minibatch_size_in_samples

Nota: per gli utenti di BrainScript, il parametro per le dimensioni del minibatch è minibatchSize; per gli utenti Python, è minibatch_size_in_samples.

CNTK ha una definizione molto specifica del minibatch_size_in_samples parametro: indica il numero di esempi tra gli aggiornamenti del modello. Un esempio qui è definito come un vettore o un tensore che scorre attraverso il sistema. Ad esempio, in un'attività di riconoscimento delle immagini, un'immagine è un esempio.

Le dimensioni minibatch per ogni epoca vengono fornite in campioni (tensori lungo un asse dinamico). Il valore predefinito è 256. È possibile usare valori diversi per diversi periodi; Ad esempio, 128*2 + 1024 (in Python) significa usare una dimensione minibatch di 128 per le prime due epoche e quindi 1024 per il resto. Si noti che "dimensioni minibatch" in CNTK significa il numero di campioni elaborati tra gli aggiornamenti del modello. Questa definizione contiene anche quando si esegue la parallelizzazione tra i lavoratori, ad esempio per K i lavoratori, il numero di campioni che ogni lavoratore elabora è minibatch_size_in_samples/K). Nel caso di input a lunghezza variabile, minibatch_size_in_samples si riferisce al numero di elementi in queste sequenze, non al numero di sequenze. SGD tenterà di adattarsi al maggior numero possibile di sequenze nel minibatch che non superano minibatch_size_in_samples i campioni totali. Se vengono specificati diversi input, i tensori vengono aggiunti al minibatch corrente fino a quando uno degli input supera .minibatch_size_in_samples

Importante, per i dati sequenziali, un esempio è un singolo elemento di una sequenza. Di conseguenza, CNTK minibatch_size_in_samplesnon fa riferimento al numero di sequenze nel minibatch, ma il numero aggregato di elementi/token di sequenza tra le sequenze che costituiscono il minibatch. CNTK ha il supporto nativo per le sequenze a lunghezza variabile, ovvero può ospitare sequenze di lunghezze altamente variabili all'interno dello stesso minibatch, senza bisogno di soluzioni alternative come bucketing. Insieme alla nozione di CNTK di specificare la frequenza di apprendimento per campione (anziché una media minibatch), ogni elemento di sequenze di qualsiasi lunghezza contribuisce alla stessa sfumatura, portando alla convergenza coerente. Molti altri toolkit definiscono le dimensioni minibatch per i dati sequenziali come numero di sequenze nel minibatch. Questo è problematico, soprattutto se le sfumature sono definite anche come medie minibatch anziché CNTK le somme minibatch, perché il contributo alla sfumatura da ogni token o passaggio in una sequenza sarebbe inversamente proporzionale alla lunghezza della sequenza. l'approccio di CNTK evita questo.

Quando vengono usati più input, è possibile che non tutti gli input abbiano la stessa lunghezza della sequenza. Ad esempio, nella classificazione della sequenza l'etichetta di ogni sequenza è un singolo token. In questo caso, l'input con il maggior numero di campioni controlla le dimensioni del minibatch. È possibile modificare questo comportamento specificando defines_mb_size=True per alcuni input, quindi le dimensioni minibatch verranno conteggiate in base alle sequenze di questo particolare input. Quando vengono specificati diversi input, è possibile impostare defines_mb_sizeTruesolo uno su .)

Nonostante la definizione chiara di minibatch_size_in_samples essere il numero di esempi tra gli aggiornamenti del modello, ci sono due occasioni in cui è necessario rilassare la definizione:

  • dati sequenziali: le sequenze a lunghezza variabile non sommano in genere esattamente le dimensioni di minibatch richieste. In questo caso, quante sequenze possono essere raggruppate in un minibatch senza superare le dimensioni di minibatch richieste (con un'eccezione: se la sequenza successiva nel corpus casuale supera la lunghezza della dimensione minibatch, le dimensioni minibatch saranno costituite da questa sequenza).
  • parallelismo dei dati: in questo caso, le dimensioni del minibatch sono approssimative, poiché l'algoritmo di casualità basato su blocchi non può garantire che ogni lavoratore riceva esattamente lo stesso numero di campioni.

Tutte le considerazioni precedenti si applicano anche a epoch_size, ma epoch_size presenta alcune differenze, vedere sopra.

MinibatchSource.next_minibatch

Il metodo MinibatchSource.next_minibatch() legge un minibatch che contiene dati per tutti i flussi di input. Quando viene chiamato durante il training, MinibatchSource.next_minibatch(minibatch_size_in_samples, input_map) selezionerà un subset casuale di campioni dal set di k dati di training, dove k=minibatch_size_in_samples.

L'implementazione garantisce che quando next_minibatch viene chiamato N time (dove N = number_of_training_samples/minibatch_size_in_samples), l'intero set di dati di training viene coperto alla fine delle N chiamate di next_minibatch. Ciò significa anche che quando next_minibatch viene chiamato 2*N il tempo, l'intero set di dati viene coperto due volte.

Altre informazioni:

  • Ogni ciclo attraverso i dati avrà un ordine casuale diverso.
  • Se si doppia la dimensione minibatch, un minibatch ora conterrà esattamente gli esempi che, prima, i due minibatches consecutivi corrispondenti avrebbero contenuto (questo può essere approssimativo se si hanno sequenze a lunghezza variabile). Ad esempio, due esecuzioni che differiscono solo in dimensioni minibatch elaborano i dati nello stesso ordine.
  • Se si interrompe e si riavvia dal checkpoint, si otterrà lo stesso ordine casuale come se non si fosse interrotto il training. Questa operazione viene implementata in base al processo di lettura/casualizzazione su un asse temporale nominale, con questo semplice algoritmo:
    • Il training procede su un asse temporale infinito nominale. Se si recupera un minibatch di dimensioni 256, il tempo nominale è in corso per 256.
    • Il corpus di training viene replicato un numero infinito di volte sull'asse temporale. Se sono presenti M esempi, la prima replica si estende sul tempo 0..M-1nominale; la seconda M..2M-1e così via.
    • Ogni replica è casuale-shuffled all'interno, ma non tra limiti di replica. Ad esempio, dopo aver elaborato esempi precisamente M , è stato visto ogni campione esattamente una volta.
    • La chiamata next_minibatch(K) offre gli esempi successivi K in questa sequenza temporale infinita riguagliata. È lo stesso di chiamare next_minibatch(1)K per i tempi.
    • Questo è tutto fatto in modo pigri.
    • Il riavvio dal checkpoint è semplice come reimpostare l'ora nominale all'ora nominale in cui è stato creato il checkpoint.