seq2seq - tensorflow raspberry pi
pasos vs num_epochs en tensorflow Getting started tutorial (5)
Estoy pasando por TensorFlow empezar tutorial . En el ejemplo tf.contrib.learn , estas son dos líneas de código:
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4, num_epochs=1000)
estimator.fit(input_fn=input_fn, steps=1000)
Me pregunto cuál es la diferencia entre los steps argumento en la función call to fit y num_epochs en la llamada numpy_input_fn . ¿No debería haber solo un argumento? ¿Cómo están conectados?
He encontrado que el código de alguna manera está tomando el min de estos dos como el número de pasos en el ejemplo de juguete del tutorial.
Editar
Gracias por todas las respuestas. En mi humilde opinión, al menos, uno de los dos parámetros num_epochs o steps debe ser redundante. Podemos calcular uno de otro. ¿Hay alguna manera de saber cuántos pasos (la cantidad de veces que los parámetros se actualizan) que realmente tomó mi algoritmo?
Tengo curiosidad de cuál tiene prioridad. ¿Y depende de otros parámetros?
Época: un pase a través de toda la información.
Tamaño de lote: el número de ejemplos visto en un lote.
Si hay 1000 ejemplos y el tamaño del lote es 100, habrá 10 pasos por época.
Las Épocas y el tamaño del lote definen por completo el número de pasos.
steps_cal = (no de ex / batch_size) * no_of_epochs
estimator.fit(input_fn=input_fn)
Si solo escribe el código anterior, entonces el valor de ''pasos'' es el dado por ''steps_cal'' en la fórmula anterior.
estimator.fit(input_fn=input_fn, steps = steps_less)
Si le da un valor (digamos ''steps_less'') menor que ''steps_cal'', entonces solo ''steps_less'' se ejecutará un no de pasos. En este caso, el entrenamiento no cubrirá el no completo de las épocas que se mencionaron.
estimator.fit(input_fn=input_fn, steps = steps_more)
Si le da un valor (digamos steps_more) más de steps_cal, entonces también se ejecutará ''steps_cal'' no de pasos.
Comencemos el orden opuesto:
1) Pasos : número de veces que se ejecutará el ciclo de entrenamiento en su algoritmo de aprendizaje para actualizar los parámetros en el modelo. En cada iteración de ciclo, procesará un fragmento de datos, que es básicamente un lote. Generalmente, este ciclo se basa en el algoritmo de Gradient Descent .
2) Tamaño del lote : el tamaño del fragmento de datos que alimenta en cada ciclo del algoritmo de aprendizaje. Puede alimentar todo el conjunto de datos, en cuyo caso el tamaño del lote es igual al tamaño del conjunto de datos. También puede alimentar un ejemplo a la vez. O puede alimentar algunos números N de ejemplos.
3) Época : la cantidad de veces que se ejecuta el conjunto de datos extrayendo lotes para alimentar el algoritmo de aprendizaje.
Digamos que tienes 1000 ejemplos. Configurar el tamaño del lote = 100, época = 1 y pasos = 200 da un proceso con una pasada (una época) en todo el conjunto de datos. En cada pasada alimentará al algoritmo un lote con 100 ejemplos. El algoritmo ejecutará 200 pasos en cada lote. En total, se ven 10 lotes. Si cambias la época a 25, harás esto 25 veces y obtendrás lotes de 25x10 en total.
¿Porqué necesitamos esto? Existen muchas variaciones en el descenso del gradiente (lote, estocástico, mini-lote), así como otros algoritmos para optimizar los parámetros de aprendizaje (por ejemplo, L-BFGS). Algunos de ellos necesitan ver los datos en lotes, mientras que otros ven un dato a la vez. Además, algunos de ellos incluyen factores / pasos aleatorios, por lo tanto, es posible que necesite varios pases en los datos para obtener una buena convergencia.
El módulo contrib.learn.io no está documentado muy bien, pero parece que la función numpy_input_fn() toma algunas matrices numpy y las agrupa juntas como entrada para un clasificador. Entonces, la cantidad de épocas probablemente signifique "cuántas veces debo pasar por los datos de entrada que tengo antes de parar". En este caso, alimentan dos arreglos de longitud 4 en 4 lotes de elementos, por lo que solo significa que la función de entrada lo hará como máximo 1000 veces antes de generar una excepción de "falta de datos". El argumento de los pasos en la función de fit() del estimador fit() es cuántas veces el estimador debe hacer el ciclo de entrenamiento. Este ejemplo en particular es algo perverso, así que déjame inventar otro para aclarar un poco (con suerte).
Digamos que tienes dos matrices numpy (muestras y etiquetas) en las que quieres entrenar. Son 100 elementos cada uno. Desea que su capacitación tome lotes con 10 muestras por lote. Entonces, después de 10 lotes, revisarás todos tus datos de entrenamiento. Esa es una época. Si configura su generador de entrada a 10 épocas, pasará por su grupo de entrenamiento 10 veces antes de detenerse, es decir, generará como máximo 100 lotes.
De nuevo, el módulo io no está documentado, pero considerando cómo funcionan otras API relacionadas con la entrada en el flujo de tensión, debería ser posible generar datos para un número ilimitado de épocas, por lo que lo único que controlará la duración del entrenamiento serán los pasos . Esto le brinda cierta flexibilidad adicional sobre cómo desea que progrese su capacitación. Puede ir varias épocas a la vez o una serie de pasos a la vez o ambas cosas o lo que sea.
Edit: TL; DR Epoca es cuando su modelo pasa por toda su información de entrenamiento una vez. El paso es cuando su modelo entrena en un solo lote (o una sola muestra si envía muestras una a una). El entrenamiento para 5 épocas en 1000 muestras 10 muestras por lote tomará 500 pasos.
Esta respuesta se basa en la experimentación que he hecho en el código de tutorial de inicio.
Mad Wombat ha dado una explicación detallada de los términos num_epochs , batch_size y steps . Esta respuesta es una extensión de su respuesta.
num_epochs : la cantidad máxima de veces que el programa puede iterar en todo el conjunto de datos en un train() . Usando este argumento, podemos restringir el número de lotes que pueden procesarse durante la ejecución de un método de train() .
batch_size - El número de ejemplos en un solo lote emitido por input_fn
pasos : cantidad de lotes que el método LinearRegressor.train() puede procesar en una ejecución
max_steps es otro argumento para el método LinearRegressor.train() . Este argumento define el número máximo de pasos (lotes) que se pueden procesar en la vida útil de los objetos LinearRegressor() .
Vamos, ¿qué significa esto? Los siguientes experimentos cambian dos líneas del código proporcionado por el tutorial. El resto del código permanece como está.
Nota: Para todos los ejemplos, suponga que el número de entrenamiento es decir, la longitud de x_train es igual a 4.
Ej 1:
input_fn = tf.estimator.inputs.numpy_input_fn( {"x": x_train}, y_train, batch_size=4, num_epochs=2, shuffle=True)
estimator.train(input_fn=input_fn, steps=10)
En este ejemplo, definimos batch_size = 4 y num_epochs = 2. Entonces, input_fn puede emitir solo 2 lotes de datos de entrada para una ejecución de train() . Aunque definimos los pasos = 10, el método train() se detiene después de 2 pasos.
Ahora, ejecute el estimator.train(input_fn=input_fn, steps=10) nuevamente. Podemos ver que se han ejecutado 2 pasos más. Podemos seguir ejecutando el método train() una y otra vez. Si ejecutamos train() 50 veces, se han ejecutado un total de 100 pasos.
Ej 2:
input_fn = tf.estimator.inputs.numpy_input_fn( {"x": x_train}, y_train, batch_size=2, num_epochs=2, shuffle=True)
estimator.train(input_fn=input_fn, steps=10)
En este ejemplo, el valor de batch_size se cambia a 2 (era igual a 4 en Ex 1). Ahora, en cada ejecución del método train() , se procesan 4 pasos. Después del cuarto paso, no hay lotes para ejecutar. Si el método train() se ejecuta nuevamente, se procesan otros 4 pasos, lo que hace un total de 8 pasos.
Aquí, el valor de los pasos no importa porque el método train() puede obtener un máximo de 4 lotes. Si el valor de los pasos es menor que ( num_epochs x training_size ) / batch_size , vea ex 3.
Ej 3:
input_fn = tf.estimator.inputs.numpy_input_fn( {"x": x_train}, y_train, batch_size=2, num_epochs=8, shuffle=True)
estimator.train(input_fn=input_fn, steps=10)
Ahora, deje batch_size = 2, num_epochs = 8 y pasos = 10. La input_fn puede emitir un total de 16 lotes en una ejecución del método train() . Sin embargo, los pasos se establecen en 10. Esto significa que aunque input_fn puede proporcionar 16 lotes para la ejecución, train() debe detenerse después de 10 pasos. Por supuesto, el método train() se puede volver a ejecutar para obtener más pasos acumulativos.
De los ejemplos 1, 2 y 3, podemos ver claramente cómo los valores de los pasos , num_epoch y batch_size afectan la cantidad de pasos que puede ejecutar el método train() en una ejecución.
El argumento max_steps del método train() restringe la cantidad total de pasos que se pueden ejecutar acumulativamente por train()
Ex 4:
Si batch_size = 4, num_epochs = 2, input_fn puede emitir 2 lotes para la ejecución de un train() . Pero, si max_steps está establecido en 20, no importa cuántas veces se ejecute train() solo se ejecutarán 20 pasos en la optimización. Esto está en contraste con el ejemplo 1, donde el optimizador puede ejecutar hasta 200 pasos si el método train() se expone 100 veces.
Espero que esto dé una comprensión detallada de lo que significan estos argumentos.
num_epochs: el número máximo de épocas (viendo cada punto de datos).
pasos: el número de actualizaciones (de parámetros).
Puede actualizar varias veces en una época cuando el tamaño del lote es menor que el número de datos de entrenamiento.