Keras e épocas, batches, taxas de aprendizado, etc

1. Intro

O Keras (agora integrado ao TensorFlow como tf.keras) oferece várias formas de controlar os parâmetros de treinamento, incluindo épocas, batch size, e até a execução do backpropagation. Além disso, ele possui funcionalidades para ajuste automático de hiperparâmetros e early stopping.

A página Épocas, batches e mini-batches introduz mais informações à respeto do seja uma "época", o que são batches, definição do tamanho dos batches e atualizações dos parãmetros de treinamento da rede.

2. Controle manual pelo usuário

a) Número de épocas (epochs) e tamanho do batch (batch_size)

No Keras, você define esses parramentos diretamente no método .fit():

model.fit(
    x_train, y_train,
    epochs=50,          # Número de épocas
    batch_size=32,      # Tamanho do mini-batch (backpropagation a cada 32 amostras)
    validation_data=(x_val, y_val)  # Dados de validação
)

• O backpropagation é executado automaticamente a cada mini-batch (não é possível "atrasá-lo" manualmente sem modificar o código do otimizador).

b) Quando o backpropagation é executado?

• O Keras adota mini-batch gradient descent por padrão, ou seja:

  • A cada época, os dados são divididos em mini-batches de tamanho batch_size.
  • O Backpropagation é executado após cada mini-batch (não é possível alterar isso sem customização).

• Se você quiser um comportamento diferente (ex.: atualização apenas ao final da época), teria que implementar um otimizador personalizado ou usar Batch Gradient Descent (definindo batch_size=len(x_train)).

3. Ajuste automático de hiperparâmetros

O Keras oferece mecanismos para adaptar dinamicamente certos parâmetros durante o treinamento:

a) Taxa de aprendizado (learning rate) adaptativa

• Otimizadores com scheduling embutido:

  • tf.keras.optimizers.Adam(learning_rate=0.001) (usa adaptação automática por padrão).
  • tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9) (momento pode ser ajustado).

• Redução automática da taxa de aprendizado (learning rate decay):

  ​x
  from keras.callbacks import LearningRateScheduler
  ​
  def lr_schedule(epoch):
      return 0.001 * 0.9 ** epoch  # Reduz a taxa a cada época
  ​
  model.fit(..., callbacks=[LearningRateScheduler(lr_schedule)])
  

No caso do exemplo de código acima, a taxa de aprendizado desceria da seguinte forma:

XXXXXX

Método de Adam (Adaptative Moment Estimation)

Funcionamento

O método de "Adam" (Adaptive Moment Estimation) (Kingma & Ba, 2015), para atualização da taxa de aprendizado, consite num otimizador adaptativo que combina os benefícios do RMSprop (adaptação por média móvel dos gradientes ao quadrado) e do momentum (média móvel dos gradientes). A principal característica do Adam é que ele ajusta individualmente a taxa de aprendizado para cada parâmetro da rede neural, com base nas estimativas de primeiro e segundo momentos dos gradientes.

Passo a Passo da Atualização no Adam:

Seja $\theta_t$ o parâmetro no tempo $t$, $g_t$ o gradiente em $t$, e $\alpha$ a taxa de aprendizado inicial.

1. Calcula-se o gradiente $g_t$ (backpropagation).

2. Estima-se o primeiro momento (média móvel dos gradientes - momentum): $m_t = \beta_1 \cdot m_{t-1} + (1 - \beta_1) \cdot g_t$

   • $\beta_1$ (tipicamente 0.9) controla o decaimento do momentum.

3. Estima-se o segundo momento (média móvel dos gradientes ao quadrado - adaptação por magnitude): $v_t = \beta_2 \cdot v_{t-1} + (1 - \beta_2) \cdot g_t^2$

   • $\beta_2$ (tipicamente 0.999) controla o decaimento da adaptação.

4. Correção de viés (importante nas primeiras iterações): $\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}$

5. Atualiza-se os parâmetros: $\theta_{t+1} = \theta_t - \alpha \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$

   • $\epsilon$ (ex.: 1E-8) evita divisão por zero!

Como a Taxa de Aprendizado 𝛼 é Adaptada?

Sobre a taxa $\alpha$:

• O termo $\dfrac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$ age como um fator de escala adaptativo:

  • Se os gradientes forem grandes e inconsistentes ($v_t$ alto), o passo de atualização é reduzido (taxa efetiva diminui).
  • Se os gradientes forem pequenos e consistentes ($v_t$ baixo), o passo de atualização é ampliado (taxa efetiva aumenta).

• Resultado: Parâmetros com gradientes irregulares têm taxas menores, enquanto parâmetros com gradientes estáveis avançam mais rapidamente.

Referência Bibliográfica

O artigo original que introduziu o Adam é o mais citado e recomendado para referência:

Kingma, D. P. and Ba, J. (2015) Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980. Disponível em: https://arxiv.org/abs/1412.6980.

Referências Adicionais Recentes

1. Reddi, S. J. et al. (2018) On the convergence of Adam and beyond. International Conference on Learning Representations (ICLR).

   • Discute problemas de convergência em Adam e propostas de melhorias (ex.: AMSGrad).

2. Loshchilov, I. and Hutter, F. (2019) Decoupled weight decay regularization. ICLR.

   • Introduz o AdamW, uma variante do Adam que corrige o weight decay.

Implementação no Keras

No Keras/TensorFlow, o Adam já inclui todas as adaptações descritas:

xxxxxxxxxx
from tensorflow.keras.optimizers import Adam
​
optimizer = Adam(
    learning_rate=0.001,  # Taxa inicial (alpha)
    beta_1=0.9,          # Decaimento do 1º momento (beta_1)
    beta_2=0.999,        # Decaimento do 2º momento (beta_2)
    epsilon=1e-8         # Termo de estabilização
)

Resumo (do método Adam)

O Adam é amplamente usado em redes profundas por sua eficiência em problemas com gradientes esparsos ou ruidosos (ex.: NLP, GANs). Para problemas onde ele oscila demais, variantes como AdamW ou NAdam podem ser melhores.

b) Momentum adaptativo

• Otimizadores como Adam e RMSprop ajustam automaticamente o momentum com base nos gradientes.

RMSprop (Detalhes)

Funcionamento do RMSprop no Keras

O RMSprop (Root Mean Square Propagation) é um método de otimização adaptativo que ajusta a taxa de aprendizado para cada parâmetro individualmente, com base na magnitude média dos gradientes recentes. Diferentemente do Adam, o RMSprop não usa momentum tradicional, mas pode ser combinado com momentum (uma variante chamada RMSprop com momentum).

Passo a Passo do RMSprop: Seja:

• $\theta_t$: Parâmetro no tempo $t$;
• $g_t$: Gradiente da Função Loss em relação a $\theta_t$;
• $\alpha$: Taxa de aprendizado inicial;
• $\gamma$: Taxa de decaimento da média móvel (geralmente 0.9);
• $\epsilon$: Termo de estabilização (ex.: 1e-8).

1. Calcula-se o gradiente $g_t$ (via backpropagation).

2. Atualiza-se a média móvel dos gradientes ao quadrado (adaptação da taxa de aprendizado):
   $E[g^2]_t = \gamma \cdot E[g^2]_{t-1} + (1 - \gamma) \cdot g_t^2$

   • $E[g^2]_t$ é uma estimativa da média exponencial dos gradientes ao quadrado.

3. Atualiza-se os parâmetros:
   $\theta_{t+1} = \theta_t - \dfrac{\alpha}{\sqrt{E[g^2]_t + \epsilon}} \cdot g_t$

   • O termo $\frac{\alpha}{\sqrt{E[g^2]_t + \epsilon}}$ ajusta a taxa de aprendizado individualmente para cada parâmetro:

     • Se $E[g^2]_t$ é grande (gradientes variáveis), o passo de atualização é reduzido;
     • Se $E[g^2]_t$ é pequeno (gradientes consistentes), o passo é ampliado.

Momentum no RMSprop?

O RMSprop puro não inclui momentum, mas o Keras permite adicioná-lo via parâmetro momentum:

xxxxxxxxxx
from tensorflow.keras.optimizers import RMSprop
​
optimizer = RMSprop(
    learning_rate=0.001,  # Taxa de aprendizado base
    rho=0.9,             # Equivalente a γ (decaimento da média móvel)
    momentum=0.0,        # Se > 0, adiciona momentum clássico
    epsilon=1e-8
)

• Se momentum > 0, o update passa a incluir um termo de momentum:
  $v_t = \text{momentum} \cdot v_{t-1} - \dfrac{\alpha}{\sqrt{E[g^2]_t + \epsilon}} \cdot g_t$

  $\theta_{t+1} = \theta_t + v_t$

A Taxa de Aprendizado é ajustada automáticamente no RMSprop?

• Sim e não:

  • O RMSprop não ajusta a taxa de aprendizado global (como o Adam faz), mas escala-a por parâmetro usando $\dfrac{\alpha}{\sqrt{E[g^2]_t + \epsilon}}$.
  • A taxa base ($\alpha$) é fixa (definida pelo usuário).

Parâmetros Controláveis pelo Usuário no RMSprop (Keras)

Referências Bibliográficas (RMSprop)

Artigo Original do RMSprop: Tieleman, T. and Hinton, G. (2012) Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning.

• Observação: O RMSprop foi introduzido em material didático, não em um paper formal.

Referências Recentes sobre Otimização Adaptativa:

1. Ruder, S. (2016) An overview of gradient descent optimization algorithms. arXiv preprint arXiv:1609.04747.

   • Disponível em: https://arxiv.org/abs/1609.04747.

2. Reddi, S. J. et al. (2018) On the convergence of Adam and beyond. International Conference on Learning Representations (ICLR).

   • Discute problemas de convergência em métodos adaptativos, incluindo RMSprop.

3. Zhang, J. et al. (2020) Why gradient clipping accelerates training: A theoretical justification for adaptivity. ICLR.

   • Analisa métodos adaptativos como RMSprop em cenários de otimização complexos.

Resumo das Características do RMSprop

O RMSprop é especialmente útil em redes recorrentes (RNNs) e problemas onde os gradientes variam muito em magnitude. Para problemas modernos, muitas vezes é substituído pelo Adam, que combina RMSprop e momentum.

4. Early stopping automático

O Keras inclui um callback pronto para parar o treinamento quando o modelo para de melhorar no conjunto de validação (não no conjunto de teste!):

xxxxxxxxxx
from keras.callbacks import EarlyStopping
​
early_stopping = EarlyStopping(
    monitor='val_loss',   # Métrica monitorada (erro no validação)
    patience=5,           # Número de épocas sem melhoria antes de parar
    restore_best_weights=True  # Restaura os melhores pesos encontrados
)
​
model.fit(
    x_train, y_train,
    validation_data=(x_val, y_val),
    callbacks=[early_stopping]  # Adiciona o callback
)

• Observação: O Keras nunca usa o conjunto de teste para tomar decisões de treinamento (como early stopping ou ajuste de LR) e sim o conjunto de validação. O conjunto de teste só deve ser avaliado no final!

Mais Detalhes

1. Monitoramento Contínuo:

   • A cada época, o Keras verifica se a métrica monitorada (ex.: val_loss) melhorou em relação ao melhor valor histórico.
   • Se melhorou, ele atualiza a cópia em memória dos melhores pesos.

2. Critério de Parada (patience):

   • Se a métrica não melhorar por patience épocas consecutivas, o treinamento é interrompido.
   • O Keras restaura automaticamente os pesos salvos em memória (os melhores encontrados).

3. Onde os Pesos São Armazenados?

   • Memória RAM: O Keras mantém apenas dois conjuntos de pesos na RAM:

     • Pesos atuais (última época treinada).
     • Melhores pesos (cópia atualizada quando a métrica melhora).

Obs.: Nenhum arquivo em disco é gerado por padrão (a menos que você use ModelCheckpoint).

O que acontece?

No caso do exemplo anterior:

• patience=5;
• suponha que melhor val_loss ocorreu na époica 20;

Neste caso o treinamento continua até a época 25 (sem melhoras) e então para.

Na época 20 os pesos foram copiados para a variável best_weigths (em RAM).

Entre as épocas 21 à 25 os pesos foram atualizados, mas best_weights não foi alterado (pois vai_lossnão melhorou).

Finalmente, o Keras descarta os pesos da época 25 e restaura best_weights (da época 20).

Usando ModelCheckpoint

Se for desejado gravar arquivos de pesos da rede, temporários em disco, pode-se usar o método ModelCheckpoint para gerá-los (formato .h5 ou .keras) refletindo os melhores pesos:

xxxxxxxxxx
from keras.callbacks import ModelCheckpoint
​
checkpoint = ModelCheckpoint(
    filepath='melhores_pesos.h5',
    monitor='val_loss',
    save_best_only=True,  # Salva apenas se val_loss melhorar
    mode='min'
)
​
model.fit(..., callbacks=[early_stopping, checkpoint])

Desta forma, um arquivo melhores_pesos.h5é gerado no disco, cada vez que val_loss atingir um novo mínimo. Pode-se ajustar ModelCheckpoint para gerar nomes de arquivos dinâmicos (ex.: pesos_epoch_{epoch:02d}.h5).

Mais Referências

• Keras EarlyStopping
• Keras ModelCheckpoint

5. Como o Keras decide com base nos dados?

• Importante: O Keras nunca ajusta parâmetros com base no conjunto de teste! Isso evitaria data leakage.

6. Funcionalidades avançadas (Keras + TensorFlow)

• Hiperparâmetros automáticos: Usando keras-tuner ou integração com TensorFlow Extended (TFX).

• Callbacks úteis:

  • ReduceLROnPlateau: Reduz a taxa de aprendizado se a validação estagnar.
  • ModelCheckpoint: Salva os melhores pesos durante o treino.

7. Como o Keras tenta evitar Overfitting

O Keras oferece mecanismos robustos para evitar overfitting, mas é crucial saber usá-los corretamente. Vamos reforçar os pontos-chave que garantem um treinamento equilibrado:

1. Early Stopping

• Interrompe o treinamento quando o modelo para de melhorar no conjunto de validação (não no treino!).
• Exemplo clássico: Se val_loss para de cair por patience=5 épocas, o treinamento para e restaura os melhores pesos.

2. Regularização Integrada

• Camadas como Dense e Conv2D aceitam parâmetros de regularização:

  xxxxxxxxxx
  Dense(64, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01))
  

• Isso penaliza pesos muito grandes, evitando ajustes extremos aos dados de treino.
  Obs.: Redes muito complexas sem Dropout ou L2 podem memorizar os dados.

3. Dropout

• "Desliga" neurônios aleatoriamente durante o treino, forçando a rede a não depender de poucos caminhos:

  xxxxxxxxxx
  tf.keras.layers.Dropout(0.5)  # 50% de chance de zerar um neurônio
  

Obs.: Redes muito complexas sem Dropout ou L2 podem memorizar os dados.

4. Validação Monitorada

• Métricas como val_loss e val_accuracy são calculadas sem backpropagation, dando uma visão realista do desempenho.

O Que Depende do Usuário?

• Escolha dos hiperparâmetros:

  • patience muito baixo pode parar o treino cedo demais.
  • batch_size e learning_rate afetam diretamente a generalização.

• Separação dos dados:

  • Conjuntos de treino/validação/teste devem ser representativos e não vazados.

Exemplo de Boa Prática no Keras

xxxxxxxxxx
model = Sequential([
    Dense(64, activation='relu', kernel_regularizer=l2(0.01)),
    Dropout(0.3),
    Dense(1)
])
​
model.compile(
    optimizer=RMSprop(learning_rate=0.001),
    loss='mse'
)
​
history = model.fit(
    x_train, y_train,
    validation_data=(x_val, y_val),
    epochs=100,
    callbacks=[
        EarlyStopping(patience=10, restore_best_weights=True),
        ModelCheckpoint('melhor_modelo.keras', save_best_only=True)
    ]
)

Resumo

1. Épocas e batch size: Definidos em model.fit(epochs=..., batch_size=...).
2. Backpropagation: Ocorre a cada mini-batch (automático).
3. Parâmetros automáticos: Otimizadores como Adam ajustam LR e momentum.
4. Early stopping: Implementado via callbacks, monitorando validação.
5. Base para decisões: Sempre validação (nunca teste).

Se precisar de mais flexibilidade, você pode criar otimizadores personalizados ou usar subclasses de tf.keras.callbacks.Callback.

Dicas Finais

Sempre visualize loss vs val_loss (usando TensorBoard/Matplotlib). Se as curvas divergirem, é sinal de overfitting:

• Treino: loss continua caindo.
• Validação: val_loss estagna ou sobe.

Combinando as técnicas acima, seu modelo terá alta performance sem overfitting!

Material Extra

1. Controle do Early Stopping no Keras

O EarlyStopping no Keras não é controlado apenas pelo parâmetro patience. Ele possui outros parâmetros importantes:

Parâmetros Principais do EarlyStopping:

Exemplo de uso avançado:

xxxxxxxxxx
early_stopping = EarlyStopping(
    monitor='val_loss',
    patience=10,          # Espera 10 épocas sem melhorar val_loss
    min_delta=0.001,      # Melhoria mínima exigida
    restore_best_weights=True,  # Volta aos melhores pesos encontrados
    mode='min'            # Minimizar val_loss
)

2. Como restore_best_weights=True Funciona?

Quando ativado, o Keras:

1. Monitora a métrica escolhida (ex.: val_loss) a cada época.
2. Armazena em memória os pesos da rede sempre que a métrica melhora.
3. Se após patience épocas não houver melhora, o treinamento é interrompido.
4. Restaura automaticamente os pesos da época onde a métrica foi a melhor.

Exemplo Prático

• Suponha que val_loss tenha o menor valor na época 15, mas o treinamento vai até a época 25 (por causa do patience=10).
• Com restore_best_weights=True, o modelo final ignora os pesos da época 25 e usar os da época 15.

Sem restore_best_weights:

• O modelo manteria os pesos da última época (possivelmente com overfitting).

3. Como Acompanhar a Função Loss em Tempo Real com Gráficos?

Você pode usar callbacks do Keras para plotar gráficos dinâmicos durante o treinamento. Duas abordagens comuns:

Opção 1: Usando History + Matplotlib

xxxxxxxxxx
import matplotlib.pyplot as plt
​
history = model.fit(
    x_train, y_train,
    validation_data=(x_val, y_val),
    epochs=100,
    callbacks=[early_stopping]
)
​
# Plotar loss e val_loss após o treino
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.legend()
plt.show()

Opção 2: Gráfico em Tempo Real com LambdaCallback

xxxxxxxxxx
from keras.callbacks import LambdaCallback
import matplotlib.pyplot as plt
import numpy as np
​
# Listas para armazenar os valores
train_losses = []
val_losses = []
​
# Callback para atualizar o gráfico a cada época
plot_callback = LambdaCallback(
    on_epoch_end=lambda epoch, logs: (
        train_losses.append(logs['loss']),
        val_losses.append(logs['val_loss']),
        plt.clf(),
        plt.plot(train_losses, label='Train Loss'),
        plt.plot(val_losses, label='Validation Loss'),
        plt.legend(),
        plt.pause(0.001)  # Pausa para atualizar o gráfico
    )
)
​
model.fit(..., callbacks=[early_stopping, plot_callback])

Observação: Para gráficos interativos e/ou mais avançados, use bibliotecas como Plotly ou TensorBoard. O TensorBoard é a ferramenta recomendada pelo Keras para visualização em tempo real.

Para saber mais sobre TensorBoard:

• Exemplo de uso de TensorBoard com RMSprop;

4. Referências Bibliográficas

Chollet, F. (2021) Deep Learning with Python. 2nd ed. Manning Publications.

• Capítulo 7: Discute early stopping e monitoramento de métricas em redes neurais.

Documentação Oficial:

• Keras EarlyStopping
• Keras Callbacks

5. Resumo

Diferença entre Conjunto de Validação vs Conjunto de Teste

Ponto crucial! Vamos esclarecer a diferença entre conjunto de validação e conjunto de teste, e por que o Keras (e boas práticas em ML) nunca usam o teste durante o treinamento.

1. Papel de Cada Conjunto de Dados

2. Por Que o Conjunto de Teste é Intocável?

• Objetivo do teste: Simular como o modelo se comportará com dados nunca vistos antes (como em produção).

• Se você usar o teste para decisões de treino (ex.: parar o treinamento quando o erro no teste melhora):

  • O modelo vazará informações do teste para o treinamento, invalidando a métrica de generalização.
  • É como "colar em uma prova": o teste deixa de ser uma avaliação imparcial.

Exemplo Prático

Suponha que você:

1. Ajuste a taxa de aprendizado com base no erro do teste.
2. Pare o treinamento quando o erro no teste for mínimo.
   ✅ Resultado aparente: "Meu modelo tem 95% de acerto no teste!"
   ❌ Problema real: O teste não é mais independente – você otimizou o modelo para ele, e ele não refletirá o desempenho real em novos dados.

3. Quando o Conjunto de Validação é Usado?

O conjunto de validação é o substituto seguro do teste durante o treinamento. Ele permite:

• Early stopping: Parar quando o erro de validação para de cair (evitando overfitting no treino).
• Ajuste de hiperparâmetros: Escolher a melhor taxa de aprendizado, batch size, etc.
• Seleção de modelos: Comparar arquiteturas de redes diferentes.

Fluxo "Correto" (esperado) no Keras:

xxxxxxxxxx
model.fit(
    x_train, y_train,
    validation_data=(x_val, y_val),  # Usado para monitorar desempenho
    callbacks=[EarlyStopping(monitor='val_loss')]  # Para se val_loss piorar
)
​
# Avaliação FINAL (após treino)
test_loss = model.evaluate(x_test, y_test)  # Só aqui o teste é usado!

4. E Se Não Houver Conjunto de Validação?

Algumas abordagens usam apenas treino e teste, mas isso é arriscado:

• Problema: Como saber se o modelo está generalizando sem um conjunto intermediário?
• Solução alternativa: Validação cruzada (cross-validation), mas é computacionalmente custoso para redes neurais.

5. Referências Bibliográficas

1. Goodfellow, I., Bengio, Y. and Courville, A. (2016) Deep Learning. MIT Press.

   • Capítulo 11 discute a importância da separação treino/validação/teste.

2. Raschka, S. (2020) Model evaluation, model selection, and algorithm selection in machine learning. arXiv:1811.12808.

   • Disponível em: https://arxiv.org/abs/1811.12808.

6. Resumo

• Validação ≠ Teste: O primeiro guia o treinamento; o segundo só avalia o resultado final.
• Keras nunca toca no teste durante o .fit(), a menos que você cometa um erro (ex.: passar x_test como validation_data).

Se você usar o teste para tomar decisões durante o treino, estará superestimando o desempenho real do modelo. A validação existe justamente para evitar isso!

Fernando Passold, em 10/06/2025