Was ist der Unterschied zwischen Schritten und Epochen in TensorFlow?

In den meisten Modellen wird ein Stufen - Parameter , die angibt , Anzahl der Schritte Daten zu überfahren . Aber ich sehe in der meisten praktischen Anwendung, dass wir auch die Anpassungsfunktion N Epochen ausführen .

Was ist der Unterschied zwischen 1000 Schritten mit 1 Epoche und 100 Schritten mit 10 Epochen? Welches ist in der Praxis besser? Gibt es logische Änderungen zwischen aufeinanderfolgenden Epochen? Daten mischen?

Eine Epoche bedeutet normalerweise eine Iteration über alle Trainingsdaten. Wenn Sie beispielsweise 20.000 Bilder und eine Stapelgröße von 100 haben, sollte die Epoche 20.000 / 100 = 200 Schritte enthalten. Normalerweise setze ich jedoch nur eine feste Anzahl von Schritten wie 1000 pro Epoche, obwohl ich einen viel größeren Datensatz habe. Am Ende der Epoche überprüfe ich die durchschnittlichen Kosten und wenn sie sich verbessern, speichere ich einen Kontrollpunkt. Es gibt keinen Unterschied zwischen den Schritten von einer Epoche zur anderen. Ich behandle sie nur als Kontrollpunkte.

Menschen mischen oft zwischen den Epochen durch den Datensatz. Ich bevorzuge die Funktion random.sample, um die Daten auszuwählen, die in meinen Epochen verarbeitet werden sollen. Angenommen, ich möchte 1000 Schritte mit einer Stapelgröße von 32 ausführen. Ich werde nur zufällig 32.000 Proben aus dem Pool der Trainingsdaten auswählen.

Ein Trainingsschritt ist eine Gradientenaktualisierung. In einem Schritt werden batch_size viele Beispiele verarbeitet.

Eine Epoche besteht aus einem vollständigen Zyklus durch die Trainingsdaten. Dies sind normalerweise viele Schritte. Wenn Sie beispielsweise 2.000 Bilder haben und eine Stapelgröße von 10 verwenden, besteht eine Epoche aus 2.000 Bildern / (10 Bilder / Schritt) = 200 Schritten.

Wenn Sie unser Trainingsbild in jedem Schritt zufällig (und unabhängig) auswählen, nennen Sie es normalerweise nicht Epoche. [Hier unterscheidet sich meine Antwort von der vorherigen. Siehe auch meinen Kommentar.]

Da ich gerade mit der tf.estimator-API experimentiere, möchte ich auch hier meine feuchten Erkenntnisse hinzufügen. Ich weiß noch nicht, ob die Verwendung von Schritten und Epochenparametern in TensorFlow konsistent ist, und daher beziehe ich mich vorerst nur auf tf.estimator (speziell tf.estimator.LinearRegressor).

Trainingsschritte definiert durch num_epochs: stepsnicht explizit definiert

estimator = tf.estimator.LinearRegressor(feature_columns=ft_cols)
train_input =  tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True)
estimator.train(input_fn=train_input)

Kommentar: Ich habe num_epochs=1für die Trainingseingabe festgelegt, und der Dokumenteintrag für numpy_input_fnsagt mir "num_epochs: Integer, Anzahl der Epochen, die über Daten iteriert werden sollen. Wenn Nonefür immer ausgeführt wird." . Mit num_epochs=1im obigen Beispiel läuft das Training genau x_train.size / batch_size times / step (in meinem Fall waren dies 175000 Schritte x_trainmit einer Größe von 700000 und batch_size4).

Trainingsschritte definiert durch num_epochs: stepsexplizit definiert höher als die Anzahl der Schritte, die implizit definiert sind durchnum_epochs=1

estimator = tf.estimator.LinearRegressor(feature_columns=ft_cols)
train_input =  tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True)
estimator.train(input_fn=train_input, steps=200000)

Kommentar: num_epochs=1In meinem Fall würde dies 175000 Schritte bedeuten ( x_train.size / batch_size mit x_train.size = 700.000 und batch_size = 4 ), und dies ist genau die Anzahl der Schritte, estimator.trainobwohl der Schrittparameter auf 200.000 festgelegt wurde estimator.train(input_fn=train_input, steps=200000).

Trainingsschritte definiert durch steps

estimator = tf.estimator.LinearRegressor(feature_columns=ft_cols)
train_input =  tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True)
estimator.train(input_fn=train_input, steps=1000)

Kommentar: Obwohl ich num_epochs=1beim Aufrufen eingestellt habe , numpy_input_fnstoppt das Training nach 1000 Schritten. Dies liegt daran, dass steps=1000in estimator.train(input_fn=train_input, steps=1000)das num_epochs=1in überschreibt tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True).

Schlussfolgerung : Unabhängig von den Parametern num_epochsfür tf.estimator.inputs.numpy_input_fnund stepsfür die estimator.trainDefinition bestimmt die Untergrenze die Anzahl der Schritte, die durchlaufen werden.

Mit einfachen Worten
: Epoche: Epoche wird als Anzahl von einem Durchgang aus dem gesamten Datensatz betrachtet.
Schritte: Im Tensorflow wird ein Schritt als Anzahl von Epochen multipliziert mit Beispielen geteilt durch die Stapelgröße betrachtet

steps = (epoch * examples)/batch size
For instance
epoch = 100, examples = 1000 and batch_size = 1000
steps = 100

Epoche: Eine Trainingsepoche repräsentiert die vollständige Verwendung aller Trainingsdaten für die Berechnung und Optimierung von Gradienten (trainieren Sie das Modell).

Schritt: Ein Trainingsschritt bedeutet, dass eine Stapelgröße von Trainingsdaten zum Trainieren des Modells verwendet wird.

Anzahl der Trainingsschritte pro Epoche: total_number_of_training_examples/ batch_size.

Gesamtzahl der Trainingsschritte: number_of_epochsx Number of training steps per epoch.

Da es noch keine akzeptierte Antwort gibt: Standardmäßig läuft eine Epoche über alle Ihre Trainingsdaten. In diesem Fall haben Sie n Schritte mit n = Trainingslänge / Batchgröße.

Wenn Ihre Trainingsdaten zu groß sind, können Sie die Anzahl der Schritte während einer Epoche begrenzen. [ Https://www.tensorflow.org/tutorials/structured_data/time_series?_sm_byp=iVVF1rD6n2Q68VSN]

Wenn die Anzahl der Schritte das von Ihnen festgelegte Limit erreicht, beginnt der Prozess von vorne und beginnt mit der nächsten Epoche. Wenn Sie in TF arbeiten, werden Ihre Daten normalerweise zuerst in eine Liste von Stapeln umgewandelt, die dem Modell zum Training zugeführt werden. Bei jedem Schritt verarbeiten Sie eine Charge.

Ich weiß nicht, ob es eine klare Antwort gibt, ob es besser ist, 1000 Schritte für eine Epoche oder 100 Schritte für 10 Epochen festzulegen. Hier sind die Ergebnisse zum Training eines CNN mit beiden Ansätzen unter Verwendung von TensorFlow-Zeitreihen-Daten-Tutorials:

In diesem Fall führen beide Ansätze zu einer sehr ähnlichen Vorhersage, nur die Trainingsprofile unterscheiden sich.

Schritte = 20 / Epochen = 100

Schritte = 200 / Epochen = 10