Qual é a diferença entre etapas e épocas no TensorFlow?

Na maioria dos modelos, há um parâmetro de etapas indicando o número de etapas a serem executadas nos dados . Mas, no entanto, vejo no uso mais prático, também executamos a função de ajuste N épocas .

Qual é a diferença entre executar 1000 etapas com 1 época e executar 100 etapas com 10 épocas? Qual é o melhor na prática? Alguma mudança lógica entre épocas consecutivas? Baralhamento de dados?

Uma época geralmente significa uma iteração sobre todos os dados de treinamento. Por exemplo, se você tiver 20.000 imagens e um tamanho de lote de 100, a época deverá conter 20.000 / 100 = 200 etapas. No entanto, geralmente apenas defino um número fixo de etapas, como 1000 por época, apesar de ter um conjunto de dados muito maior. No final da época, verifico o custo médio e, se ele melhorou, salvo um ponto de verificação. Não há diferença entre as etapas de uma época para outra. Eu apenas os trato como postos de controle.

As pessoas geralmente embaralham o conjunto de dados entre épocas. Prefiro usar a função random.sample para escolher os dados a serem processados ​​em minhas épocas. Digamos que eu queira executar 1000 etapas com um tamanho de lote de 32. Apenas selecionarei aleatoriamente 32.000 amostras do conjunto de dados de treinamento.

Uma etapa de treinamento é uma atualização de gradiente. Em uma etapa batch_size, muitos exemplos são processados.

Uma época consiste em um ciclo completo através dos dados de treinamento. Isso geralmente é muitas etapas. Por exemplo, se você possui 2.000 imagens e usa um tamanho de lote de 10, uma época consiste em 2.000 imagens / (10 imagens / etapa) = 200 etapas.

Se você escolher nossa imagem de treinamento aleatoriamente (e independente) em cada etapa, normalmente não a chamará de época. [É aqui que minha resposta difere da anterior. Veja também o meu comentário.]

Como atualmente estou experimentando a API tf.estimator, também gostaria de adicionar minhas descobertas orvalhadas aqui. Ainda não sei se o uso de parâmetros de etapas e épocas é consistente em todo o TensorFlow e, portanto, estou apenas relacionado ao tf.estimator (especificamente tf.estimator.LinearRegressor) por enquanto.

Etapas de treinamento definidas por num_epochs: stepsnão definidas explicitamente

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)

Comentário: Eu configurei num_epochs=1para a entrada de treinamento e a entrada de documento para numpy_input_fnme diz "num_epochs: Inteiro, número de épocas para iterar nos dados. Se Nonefor executado para sempre". . No num_epochs=1exemplo acima, o treinamento é executado exatamente x_train.size / batch_size times / steps (no meu caso, foram 175000 etapas, x_traincom um tamanho de 700000 e batch_size4).

Etapas de treinamento definidas por num_epochs: stepsexplicitamente definidas maiores que o número de etapas definidas implicitamente pornum_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)

Comentário: num_epochs=1no meu caso, significaria 175000 etapas ( x_train.size / batch_size com x_train.size = 700.000 e batch_size = 4 ) e esse é exatamente o número de etapas, estimator.trainembora o parâmetro steps tenha sido definido como 200.000 estimator.train(input_fn=train_input, steps=200000).

Etapas de treinamento definidas por 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)

Comentário: Embora eu tenha definido num_epochs=1ao ligar, numpy_input_fno treinamento para após 1000 etapas. Isso ocorre porque steps=1000no estimator.train(input_fn=train_input, steps=1000)substitui o num_epochs=1no tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True).

Conclusão : Quaisquer que sejam os parâmetros num_epochspara tf.estimator.inputs.numpy_input_fne stepspara estimator.traindefinir, o limite inferior determina o número de etapas que serão executadas.

Em palavras fáceis
Epoch: Epoch é considerado o número de uma passagem de todo o conjunto de dados
Etapas: No tensorflow, uma etapa é considerada como o número de épocas multiplicado por exemplos divididos pelo tamanho do lote

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

Época: uma época de treinamento representa o uso completo de todos os dados de treinamento para cálculos e otimizações de gradientes (treine o modelo).

Etapa: uma etapa de treinamento significa usar um tamanho de lote de dados de treinamento para treinar o modelo.

Número de etapas de treinamento por época: total_number_of_training_examples/ batch_size.

Número total de etapas de treinamento: number_of_epochsx Number of training steps per epoch.

Como ainda não há resposta aceita: por padrão, uma época percorre todos os seus dados de treinamento. Nesse caso, você possui n etapas, com n = Training_lenght / batch_size.

Se seus dados de treinamento forem muito grandes, você poderá limitar o número de etapas durante uma época. [ Https://www.tensorflow.org/tutorials/structured_data/time_series?_sm_byp=iVVF1rD6n2Q68VSN]

Quando o número de etapas atingir o limite que você definiu, o processo será iniciado novamente, iniciando a próxima época. Ao trabalhar no TF, seus dados geralmente são transformados primeiro em uma lista de lotes que serão alimentados no modelo para treinamento. Em cada etapa, você processa um lote.

Quanto a se é melhor definir 1000 etapas para uma época ou 100 etapas com 10 épocas, não sei se há uma resposta direta. Mas aqui estão os resultados do treinamento de uma CNN com as duas abordagens, usando os tutoriais de dados das séries temporais do TensorFlow:

Nesse caso, ambas as abordagens levam a previsões muito semelhantes, apenas os perfis de treinamento diferem.

etapas = 20 / época = 100

etapas = 200 / épocas = 10