Evolução do treino (com gráfico MSE)

Intro

No Keras, a função de custo baseada no Erro Quadrático Médio (MSE) é implementada como MeanSquaredError e pode ser usada diretamente ao compilar o modelo. O MSE é calculado automaticamente durante o treinamento sobre o conjunto de treino. Para calcular o MSE sobre o conjunto de teste, você pode usar o método evaluate do modelo após cada época.

Para acumular os valores de MSE para os conjuntos de treino e teste a cada época e plotá-los em um gráfico, você pode usar callbacks personalizados no Keras. Abaixo, segue um exemplo de como fazer isso.

Exemplo_1 de Código

​x
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import Callback
​
# Dados de exemplo
X_train = np.random.rand(1000, 10)
y_train = np.random.rand(1000, 1)
X_test = np.random.rand(200, 10)
y_test = np.random.rand(200, 1)
​
# Definindo o modelo
model = Sequential()
model.add(Dense(16, input_dim=10, activation='relu'))
model.add(Dense(1)) # Saída linear para regressão
​
# Compilando o modelo com MSE como função de custo
model.compile(optimizer='adam', loss='mean_squared_error')
​
# Vetores para armazenar os valores de MSE
train_mse = []
test_mse = []
​
# Callback personalizado para calcular MSE no conjunto de teste a cada época
class MSECallback(Callback):
  def on_epoch_end(self, epoch, logs=None):
    \# Calcula o MSE no conjunto de treino
    train_loss = logs['loss']
    train_mse.append(train_loss)
​
    \# Calcula o MSE no conjunto de teste
    test_loss = self.model.evaluate(X_test, y_test, verbose=0)
    test_mse.append(test_loss)
​
    print(f"Época {epoch + 1}: MSE Treino = {train_loss:.4f}, MSE Teste = {test_loss:.4f}")
​
# Instanciando o callback
mse_callback = MSECallback()
​
# Treinando o modelo
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test), callbacks=[mse_callback])
​
# Plotando os valores de MSE
plt.plot(train_mse, label='MSE Treino')
plt.plot(test_mse, label='MSE Teste')
plt.xlabel('Época')
plt.ylabel('MSE')
plt.title('MSE vs Época')
plt.legend()
plt.show()

Detalhes do Código

1. Dados de Exemplo:

   • X_train e y_train são os dados de treino.
   • X_test e y_test são os dados de teste.

2. Modelo:

   • Uma rede neural simples com uma camada oculta e uma camada de saída linear para regressão.

3. Função de Custo:

   • A função de custo é definida como mean_squared_error ao compilar o modelo.

4. Callback Personalizado:

   • O callback MSECallback é criado para calcular o MSE no conjunto de teste a cada época.
   • O método on_epoch_end é chamado no final de cada época, onde:
   • O MSE no conjunto de treino é obtido diretamente dos logs (logs['loss']).
   • O MSE no conjunto de teste é calculado usando o método evaluate.

5. Armazenamento e Plotagem:

   • Os valores de MSE para treino e teste são armazenados em listas (train_mse e test_mse).
   • Após o treinamento, os valores são plotados em um gráfico usando matplotlib.

Saída Esperada

• Um gráfico mostrando o MSE no conjunto de treino e no conjunto de teste ao longo das épocas.
• A cada época, o MSE para treino e teste é impresso no console.

Exemplo_2: Código Melhorado (plotagem dinâmica)

Para plotar o gráfico dinamicamente (ou seja, atualizar o gráfico enquanto a rede está sendo treinada), você pode usar a biblioteca matplotlib em conjunto com o método plt.pause() para atualizar o gráfico a cada época. Abaixo, vou modificar o código anterior para incluir a plotagem dinâmica.

Código:

xxxxxxxxxx
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import Callback
​
# Dados de exemplo
X_train = np.random.rand(1000, 10)
y_train = np.random.rand(1000, 1)
X_test = np.random.rand(200, 10)
y_test = np.random.rand(200, 1)
​
# Definindo o modelo
model = Sequential()
model.add(Dense(16, input_dim=10, activation='relu'))
model.add(Dense(1))  # Saída linear para regressão
​
# Compilando o modelo com MSE como função de custo
model.compile(optimizer='adam', loss='mean_squared_error')
​
# Vetores para armazenar os valores de MSE
train_mse = []
test_mse = []
​
# Configuração do gráfico
plt.ion()  # Ativa o modo interativo do matplotlib
fig, ax = plt.subplots()
ax.set_xlabel('Época')
ax.set_ylabel('MSE')
ax.set_title('MSE vs Época')
train_line, = ax.plot([], [], label='MSE Treino')
test_line, = ax.plot([], [], label='MSE Teste')
ax.legend()
plt.show()
​
# Callback personalizado para calcular MSE no conjunto de teste a cada época
class MSECallback(Callback):
    def on_epoch_end(self, epoch, logs=None):
        # Calcula o MSE no conjunto de treino
        train_loss = logs['loss']
        train_mse.append(train_loss)
​
        # Calcula o MSE no conjunto de teste
        test_loss = self.model.evaluate(X_test, y_test, verbose=0)
        test_mse.append(test_loss)
​
        # Atualiza o gráfico
        train_line.set_xdata(np.arange(len(train_mse)))
        train_line.set_ydata(train_mse)
        test_line.set_xdata(np.arange(len(test_mse)))
        test_line.set_ydata(test_mse)
        ax.relim()  # Recalcula os limites dos eixos
        ax.autoscale_view()  # Ajusta a escala dos eixos
        plt.draw()
        plt.pause(0.1)  # Pausa para atualizar o gráfico
​
        print(f"Época {epoch + 1}: MSE Treino = {train_loss:.4f}, MSE Teste = {test_loss:.4f}")
​
# Instanciando o callback
mse_callback = MSECallback()
​
# Treinando o modelo
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test), callbacks=[mse_callback])
​
# Manter o gráfico aberto após o treinamento
plt.ioff()
plt.show()

Explicação das Modificações

1. Modo Interativo do Matplotlib:

• plt.ion(): Ativa o modo interativo do matplotlib, permitindo que o gráfico seja atualizado dinamicamente.

2. Configuração do Gráfico:

   • fig, ax = plt.subplots(): Cria uma figura e um eixo para o gráfico.
   • train_line, = ax.plot([], [], label='MSE Treino'): Cria uma linha vazia para o MSE do treino.
   • test_line, = ax.plot([], [], label='MSE Teste'): Cria uma linha vazia para o MSE do teste.
   • ax.legend(): Adiciona uma legenda ao gráfico.

3. Atualização Dinâmica:

   • No callback MSECallback, após calcular o MSE para treino e teste, as linhas do gráfico são atualizadas com os novos valores:

     xxxxxxxxxx
     train_line.set_xdata(np.arange(len(train_mse)))
     train_line.set_ydata(train_mse)
     test_line.set_xdata(np.arange(len(test_mse)))
     test_line.set_ydata(test_mse)
     

   • ax.relim() e ax.autoscale_view(): Ajustam os limites e a escala dos eixos para acomodar os novos dados.

   • plt.draw(): Redesenha o gráfico.

   • plt.pause(0.1): Pausa a execução por 0.1 segundos para permitir a atualização do gráfico.

4. Manter o Gráfico Aberto:

   • plt.ioff(): Desativa o modo interativo após o treinamento.
   • plt.show(): Mantém o gráfico aberto após o término do treinamento.

Saída Esperada

• Um gráfico que é atualizado a cada época, mostrando o MSE no conjunto de treino e no conjunto de teste.
• O gráfico é exibido dinamicamente enquanto o modelo está sendo treinado.

Observações

1. Desempenho:

   • A atualização dinâmica do gráfico pode tornar o treinamento mais lento, especialmente para um grande número de épocas ou conjuntos de dados grandes.
   • Se o desempenho for um problema, você pode atualizar o gráfico a cada N épocas em vez de a cada época.

2. Personalização:

   • Você pode personalizar o gráfico (cores, estilos de linha, etc.) conforme necessário.

3. Outras Bibliotecas:

   • Se você preferir uma solução mais interativa, pode usar bibliotecas como Plotly ou Bokeh, que oferecem funcionalidades mais avançadas para gráficos dinâmicos.

Com essas modificações, você poderá visualizar o progresso do treinamento em tempo real, o que é útil para monitorar o desempenho do modelo e detectar problemas como overfitting ou underfitting.

Observações Finais

1. Validação Automática:

   • O Keras já calcula o MSE no conjunto de validação (ou teste) automaticamente se você passar validation_data no método fit. No entanto, o callback personalizado permite maior controle sobre o processo.

2. Eficiência:

   • Calcular o MSE no conjunto de teste a cada época pode ser computacionalmente custoso para conjuntos de dados grandes. Nesse caso, você pode calcular o MSE no conjunto de teste a cada N épocas.

3. Outras Métricas:

   • Você pode adaptar o callback para calcular outras métricas, como MAE (Mean Absolute Error) ou R².

Esse método é flexível e pode ser adaptado para diferentes cenários de treinamento e avaliação de modelos.

Outros métodos de testar evolução do treino da rede: $R^2 \times MSE$.

20/03/2025