Epoca vs Iterazione durante l'allenamento delle reti neurali
Risposte:
Nella terminologia della rete neurale:
- uno un'epoca = un passaggio in avanti e un passaggio all'indietro tutti gli esempi di addestramento
- dimensione del lotto = il numero di esempi di allenamento in un passaggio avanti / indietro. Maggiore è la dimensione del batch, maggiore sarà lo spazio di memoria necessario.
- numero di iterazioni = numero di passaggi, ogni passaggio utilizzando [dimensione batch] numero di esempi. Per essere chiari, un passaggio = un passaggio in avanti + un passaggio all'indietro (non contiamo il passaggio in avanti e il passaggio all'indietro come due passaggi diversi).
Esempio: se hai 1000 esempi di addestramento e la dimensione del tuo lotto è 500, occorreranno 2 iterazioni per completare 1 epoca.
Il termine "batch" è ambiguo: alcune persone lo usano per designare l'intero set di allenamento, e alcune persone lo usano per fare riferimento al numero di esempi di allenamento in un passaggio avanti / indietro (come ho fatto in questa risposta). Per evitare quell'ambiguità e chiarire che il batch corrisponde al numero di esempi di allenamento in un passaggio avanti / indietro, si può usare il termine mini-batch .
Epoca e iterazione descrivono cose diverse.
Epoca
Un epoca descrive il numero di volte in cui l'algoritmo vede l' intera set di dati. Quindi, ogni volta che l'algoritmo ha visto tutti i campioni nel set di dati, un'epoca è stata completata.
Iterazione
Un'iterazione descrive il numero di volte che un lotto di dati passati attraverso l'algoritmo. Nel caso delle reti neurali, ciò significa che il passaggio in avanti e il passaggio all'indietro . Pertanto, ogni volta che si passa un batch di dati attraverso la NN, è stata completata un'iterazione .
Esempio
Un esempio potrebbe renderlo più chiaro.
Supponi di avere un set di dati di 10 esempi (o esempi). Hai una dimensione batch di 2 e hai specificato che desideri che l'algoritmo venga eseguito per 3 epoche.
Pertanto, in ogni epoca, hai 5 lotti (10/2 = 5). Ogni batch viene passato attraverso l'algoritmo, quindi hai 5 iterazioni per epoca. Dato che hai specificato 3 epoche, hai un totale di 15 iterazioni (5 * 3 = 15) per l'allenamento.
Molti algoritmi di addestramento della rete neurale implicano la realizzazione di più presentazioni dell'intero set di dati sulla rete neurale. Spesso, una singola presentazione dell'intero set di dati viene definita "epoca". Al contrario, alcuni algoritmi presentano dati alla rete neurale un singolo caso alla volta.
"Iterazione" è un termine molto più generale, ma da quando lo hai chiesto insieme a "epoca", presumo che la tua fonte si riferisca alla presentazione di un singolo caso a una rete neurale.
Per comprendere la differenza tra questi è necessario comprendere l' algoritmo di discesa del gradiente e le sue varianti .
Prima di iniziare con la risposta effettiva, vorrei creare alcuni retroscena.
Un batch è il set di dati completo. La sua dimensione è il numero totale di esempi di addestramento nel set di dati disponibile.
La dimensione del mini-batch è il numero di esempi che l'algoritmo di apprendimento elabora in un unico passaggio (avanti e indietro).
Un mini-batch è una piccola parte dell'insieme di dati di una determinata dimensione di mini-batch .
Iterazioni è il numero di lotti di dati che l'algoritmo ha visto (o semplicemente il numero di passaggi che l'algoritmo ha fatto sul set di dati).
Epochs è il numero di volte in cui un algoritmo di apprendimento vede il set di dati completo. Ora, questo potrebbe non essere uguale al numero di iterazioni , poiché il set di dati può anche essere elaborato in mini-batch, in sostanza, un singolo passaggio può elaborare solo una parte del set di dati. In tali casi, il numero di iterazioni non è uguale al numero di epoche .
Nel caso della discesa del gradiente in lotti, l'intero lotto viene elaborato su ogni passaggio di allenamento. Pertanto, l'ottimizzatore di discesa gradiente produce una convergenza più uniforme rispetto alla discesa gradiente mini-batch, ma richiede più tempo. La discesa del gradiente in lotti è garantita per trovare un ottimale se esiste.
La discesa gradiente stocastica è un caso speciale di discesa con gradiente mini-batch in cui la dimensione del mini-batch è 1 .
Hai dei dati di allenamento che mescoli e raccogli i mini-lotti da esso. Quando si regolano pesi e distorsioni utilizzando un mini-batch, è stata completata un'iterazione. Una volta esauriti i tuoi mini-lotti, hai completato un'epoca. Quindi mescoli di nuovo i tuoi dati di allenamento, scegli di nuovo i tuoi mini-batch e ripeti tutti. Sarebbe la tua seconda epoca.
In genere, dividerai il tuo set di test in piccoli lotti per consentire alla rete di imparare e farai l'addestramento passo dopo passo attraverso il tuo numero di livelli, applicando la discesa gradiente fino in fondo. Tutti questi piccoli passi possono essere chiamati iterazioni .
Un epoca corrisponde a tutto il training set passare attraverso l'intera rete una volta. Può essere utile limitarlo, ad esempio per combattere il sovrautilizzo.
Un'epoca contiene alcune iterazioni. Questo è in realtà ciò che è questa "epoca". Definiamo "epoca" come il numero di iterazioni sul set di dati per formare la rete neurale.
Per quanto ne so, quando è necessario addestrare un NN, è necessario un set di dati di grandi dimensioni che coinvolge molti elementi di dati. quando NN viene addestrato, gli elementi di dati entrano in NN uno alla volta, che viene chiamato iterazione; Quando l'intero set di dati passa, viene chiamato un'epoca.
Credo che l'iterazione sia equivalente a un singolo batch forward + backprop in batch SGD. Epoch sta attraversando l'intero set di dati una volta (come menzionato da qualcun altro).
Immagino nel contesto della terminologia della rete neurale:
- Epoca: quando la rete finisce per superare l'intero set di addestramento (ovvero, una volta per ogni istanza di addestramento), completa un'epoca .
Per definire l' iterazione (ovvero passaggi ), devi prima conoscere le dimensioni del batch :
Dimensione del batch: probabilmente non ti piacerebbe elaborare tutte le istanze di training tutte in un passaggio in avanti poiché è inefficiente e richiede una grande quantità di memoria. Quindi, ciò che viene comunemente fatto è suddividere le istanze di addestramento in sottoinsiemi (ad es. Batch), eseguire un passaggio sul sottoinsieme selezionato (ad es. Batch) e quindi ottimizzare la rete tramite backpropagation. Il numero di istanze di training all'interno di un sottoinsieme (ad es. Batch) è chiamato batch_size .
Iterazione: (ovvero fasi di addestramento) Sai che la tua rete deve superare tutte le istanze di addestramento in un unico passaggio per completare un'epoca. Ma aspetta! quando si suddividono le istanze di training in batch, ciò significa che è possibile elaborare solo un batch (un sottoinsieme di istanze di training) in un passaggio in avanti, quindi per quanto riguarda gli altri batch? È qui che entra in gioco il termine Iterazione :
- Definizione: il numero di passaggi in avanti (il numero di batch creati) che la rete deve eseguire per completare un'epoca (vale a dire, passando su tutte le istanze di addestramento) si chiama Iterazione .
Ad esempio, quando si hanno 1000 istanze di allenamento e si desidera eseguire il batch con dimensioni di 10; devi fare 10000/10 = 1000 iterazioni per completare un'epoca.
Spero che questo possa rispondere alla tua domanda!
l'epoca è un'iterazione del sottoinsieme dei campioni per l'addestramento, ad esempio l'algoritmo di discesa gradiente in rete neutra. Un buon riferimento è: http://neuralnetworksanddeeplearning.com/chap1.html
Si noti che la pagina ha un codice per l'algoritmo di discesa gradiente che utilizza l'epoca
def SGD(self, training_data, epochs, mini_batch_size, eta,
test_data=None):
"""Train the neural network using mini-batch stochastic
gradient descent. The "training_data" is a list of tuples
"(x, y)" representing the training inputs and the desired
outputs. The other non-optional parameters are
self-explanatory. If "test_data" is provided then the
network will be evaluated against the test data after each
epoch, and partial progress printed out. This is useful for
tracking progress, but slows things down substantially."""
if test_data: n_test = len(test_data)
n = len(training_data)
for j in xrange(epochs):
random.shuffle(training_data)
mini_batches = [
training_data[k:k+mini_batch_size]
for k in xrange(0, n, mini_batch_size)]
for mini_batch in mini_batches:
self.update_mini_batch(mini_batch, eta)
if test_data:
print "Epoch {0}: {1} / {2}".format(
j, self.evaluate(test_data), n_test)
else:
print "Epoch {0} complete".format(j)
Guarda il codice. Per ogni epoca, generiamo casualmente un sottoinsieme degli input per l'algoritmo di discesa gradiente. Perché l'epoca è efficace è anche spiegato nella pagina. Per favore dai un'occhiata.
Un passaggio di formazione completo sull'intero set di dati in modo tale che ogni esempio sia stato visto una volta. Pertanto, un'epoca rappresenta iterazioni di addestramento per dimensione N / batch , dove N è il numero totale di esempi.
Un singolo aggiornamento dei pesi di un modello durante l'allenamento. Un'iterazione consiste nel calcolare i gradienti dei parametri rispetto alla perdita su un singolo batch di dati.
come bonus:
L'insieme di esempi utilizzati in un'iterazione (ovvero un aggiornamento gradiente ) dell'addestramento del modello .
Vedi anche le dimensioni del lotto .
fonte: https://developers.google.com/machine-learning/glossary/
1.Epoch è 1 ciclo completo in cui la rete neurale ha visto tutti i suoi dati.
2. Si potrebbe dire che 100.000 immagini per addestrare il modello, tuttavia lo spazio di memoria potrebbe non essere sufficiente per elaborare tutte le immagini contemporaneamente, quindi abbiamo diviso la formazione del modello su blocchi di dati più piccoli chiamati batch. ad esempio, la dimensione del lotto è 100.
3. Dobbiamo coprire tutte le immagini utilizzando più lotti. Quindi avremo bisogno di 1000 iterazioni per coprire tutte le 100.000 immagini. (100 batch size * 1000 iterations)
4. Una volta che la rete neurale guarda tutti i dati, viene chiamata 1 epoca (punto 1). Uno potrebbe aver bisogno di più epoche per addestrare il modello. (diciamo 10 epoche).