chapeuzinho_steampunk

Rede Chapeuzinho Vermelho - Parte 2

Vamos corrigir o código para que a rede "Chapeuzinho Vermelho" tenha apenas uma camada oculta com 3 neurônios, conforme solicitado. Além disso, vou explicar como você pode associar labels (etiquetas) às entradas e saídas para identificar o que cada ponto representa.

Código corrigido (rede com apenas 1 camada oculta):


xxxxxxxxxx
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Definindo o modelo
model = Sequential()
# Camada de entrada e única camada oculta
model.add(Dense(units=3, input_dim=6, activation='sigmoid'))  # 6 entradas e 3 neurônios na camada oculta
# Camada de saída
model.add(Dense(units=7, activation='sigmoid'))  # 7 neurônios na camada de saída
# Compilando o modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Resumo do modelo
model.summary()

Explicação das mudanças

Apenas uma camada oculta:
- Foi removida a segunda camada oculta (Dense(units=3, activation='sigmoid')), deixando apenas uma camada oculta com 3 neurônios.
- A camada de entrada (input_dim=6) se conecta diretamente à camada oculta, que por sua vez se conecta à camada de saída.
Função de ativação sigmoidal:
- A função de ativação sigmoidal é usada tanto na camada oculta quanto na camada de saída, garantindo que os valores de saída estejam no intervalo [0, 1].
Resumo do modelo:
- O método model.summary() exibe a arquitetura da rede, mostrando o número de parâmetros em cada camada.

Executando...

Executando esta primeira parte num interpretador Python, obtemos:


xxxxxxxxxx
(tf2.10) fernandopassold@MacBook-Pro-de-Fernando [21:38:03] [/Volumes/DADOS/Users/fpassold/Documents/IA/2025/RNs/Red] 
-> % python red_parte_1.py 
2025-03-17 21:38:12.399863: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2025-03-17 21:38:16.334596: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 3)                 21        
                                                                 
 dense_1 (Dense)             (None, 7)                 28        
                                                                 
=================================================================
Total params: 49
Trainable params: 49
Non-trainable params: 0
_________________________________________________________________
(tf2.10) fernandopassold@MacBook-Pro-de-Fernando [21:38:16] [/Volumes/DADOS/Users/fpassold/Documents/IA/2025/RNs/Red] 
-> %

Obs.: Para executar estes scripts se faz necessário já ter o TensorFlow instalado. instruções sobre Como instalar o TensorFlow, clicar aqui.

Associando labels (etiquetas) aos neurônios

Em redes neurais, os dados de entrada e saída são geralmente representados como arrays numéricos. No entanto, você pode associar labels (etiquetas) a esses dados para identificar o que cada ponto representa. Isso é feito fora do modelo, durante o pré-processamento dos dados ou na exibição dos resultados.

Aqui está um exemplo de como você pode associar labels às entradas e saídas:

Exemplo de dados com labels


xxxxxxxxxx
# Dados de entrada com labels
input_labels = ["Característica 1", "Característica 2", "Característica 3", "Característica 4", "Característica 5", "Característica 6"]
# Dados de saída com labels
output_labels = ["Saída 1", "Saída 2", "Saída 3", "Saída 4", "Saída 5", "Saída 6", "Saída 7"]
# Dados de treinamento (exemplo)
X_train = [
    [0, 1, 0, 1, 0, 1],  # Exemplo 1
    [1, 0, 1, 0, 1, 0],  # Exemplo 2
    [0, 0, 1, 1, 0, 0]   # Exemplo 3
]
# Rótulos de treinamento (exemplo)
y_train = [
    [0, 1, 0, 1, 0, 1, 0],  # Rótulo para o Exemplo 1
    [1, 0, 1, 0, 1, 0, 1],  # Rótulo para o Exemplo 2
    [0, 0, 1, 1, 0, 0, 1]   # Rótulo para o Exemplo 3
]

Acrescentando labels aos nerônios da camada invisível

É possível associar labels (etiquetas) aos neurônios da camada oculta (invisível) para facilitar a interpretação do que cada neurônio representa. No entanto, é importante entender que os neurônios em uma camada oculta não têm um significado intrínseco ou direto como os neurônios de entrada ou saída. Eles aprendem representações internas dos dados durante o treinamento, e essas representações podem não ser diretamente interpretáveis.

Ainda assim, você pode atribuir labels aos neurônios da camada oculta para fins de visualização ou análise. Abaixo, vou mostrar como você pode fazer isso. No código Python, após definir a rede, você pode acrescentar linhas com:


xxxxxxxxxx
# Labels para os neurônios da camada oculta
hidden_layer_labels = ["Neurônio Oculta 1", "Neurônio Oculta 2", "Neurônio Oculta 3"]

Exibindo resultados com labels

Após treinar o modelo, você pode exibir os resultados associando os labels às saídas:


xxxxxxxxxx
# Treinando o modelo
model.fit(X_train, y_train, epochs=10, batch_size=1)
# Fazendo previsões
predictions = model.predict(X_train)
# Exibindo previsões com labels
for i, pred in enumerate(predictions):
    print(f"Exemplo {i + 1}:")
    for j, value in enumerate(pred):
        print(f"  {output_labels[j]}: {value:.4f}")

Saída esperada

Se o modelo for treinado e fizer previsões, a saída será algo como:


xxxxxxxxxx
Exemplo 1:
  Saída 1: 0.1234
  Saída 2: 0.9876
  Saída 3: 0.4567
  Saída 4: 0.8765
  Saída 5: 0.2345
  Saída 6: 0.7654
  Saída 7: 0.3456
Exemplo 2:
  Saída 1: 0.6543
  Saída 2: 0.3210
  Saída 3: 0.7890
  Saída 4: 0.4321
  Saída 5: 0.5678
  Saída 6: 0.8901
  Saída 7: 0.1234
...

Versão 3 da Rede Chapeuzinho Vermelho

Vamos incrementar algo mais o código da rede para o Chapeuzinho Vermelho acrescentando 2 funções extras:

Acrescentando gráficos de barras para as saídas

Função bargraph:

Recebe um valor de ativação (entre 0 e 1) e retorna uma string com caracteres #
O número de caracteres # é proporcional ao valor de ativação, arredondado para o inteiro mais próximo.
Por exemplo:
- Se o valor for 0, a barra será vazia.
- Se o valor for 0.5, a barra terá 5 caracteres #.
- Se o valor for 1, a barra terá 10 caracteres #.
Exibição das previsões com barras:
- Para cada exemplo de entrada, as previsões são exibidas com os labels correspondentes.
- A função bargraph é usada para gerar a barra de caracteres # proporcional ao valor de ativação.
- A função bargraph é flexível e pode ser ajustada para diferentes comprimentos máximos de barras (alterando o parâmetro max_length).

Acrescentado apresentação das entradas ativadas

Função activated_inputs:

Recebe os dados de entrada (input_data) e os labels das entradas (input_labels`).
Identifica quais entradas estão ativadas (valor 1) e retorna uma string com os labels correspondentes, separados por vírgula.

Idéia Final

Para cada exemplo de entrada, a função activated_inputs é chamada para exibir os labels das entradas ativadas.
Em seguida, as saídas são exibidas com as barras de caracteres, como antes.

Versão 5 do código

Segue listagem red_version_5.py :


xxxxxxxxxx
"""
Fernando Passold, em 18/03/2025
Parte 1: Inicializando rede do Chapeuzinho Vermelho (rede MLP> 6 x 3 x 7)
"""
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import numpy as np
import time  # Importando a biblioteca time para medir o tempo
import matplotlib.pyplot as plt  # Importando a biblioteca para gráficos
# Eventualmente será necessário `conda install matplotlib`
# Acrescentando Função para exibir exibe uma barra de caracteres # proporcional ao valor de ativação
def bargraph(value, max_length=20):
    """
    Retorna uma string com caracteres '#' proporcional ao valor.
    - value: Valor de ativação (entre 0 e 1).
    - max_length: Número máximo de caracteres '#' (padrão é 10).
    """
    num_hashes = round(value * max_length)  # Arredonda para o número inteiro mais próximo
    return '#' * num_hashes
# Função para exibir os labels das entradas ativadas
def activated_inputs(input_data, input_labels):
    """
    Retorna uma string com os labels das entradas ativadas (valor = 1).
    - input_data: Dados de entrada (array binário).
    - input_labels: Lista de labels correspondentes às entradas.
    """
    activated = [input_labels[i] for i, value in enumerate(input_data) if value == 1]
    return ', '.join(activated)
# Função para calcular o comprimento máximo dos labels
def max_label_length(labels):
    """
    Retorna o comprimento da maior string em uma lista de labels.
    - labels: Lista de strings.
    """
    return max(len(label) for label in labels)
# Definindo o modelo
model = Sequential()
# Camada de entrada e única camada oculta
model.add(Dense(units=3, input_dim=6, activation='sigmoid'))  # 6 entradas e 3 neurônios na camada oculta
# Camada de saída
model.add(Dense(units=7, activation='sigmoid'))  # 7 neurônios na camada de saída
# Compilando o modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
#### Parte 2: Associando labels (etiquetas) às entradas e saída da rede
# Dados de entrada com labels
input_labels = ["1. Grandes orelhas", "2. Grandes olhos", "3. Grandes dentes", "4. Gentil", "5. Enrugado", "6. Bonito"]
# Dados de saída com labels
output_labels = ["1. Fugir", "2. Gritar", "3. Procurar pelo lenhador", "4. Beijar na bochecha", "5. Aproximar-se", "6. Oferecer comida", "7. Flertar"]
# Calcula o comprimento máximo dos labels de saida
max_input_label_length = max_label_length(output_labels)
# Isso é usado para determinar quantos espaços em branco devem ser adicionados aos labels menores.
# Labels para os neurônios da camada oculta
hidden_layer_labels = ["1. Lobo", "2. Avó", "3. Lenhador"]
# Resumo do modelo
model.summary()
# Dados de treinamento (exemplo)
X_train = [
#    1  2  3  4  5  6
    [1, 1, 1, 0, 0, 0],  # É o Lobo 1
    [1, 1, 1, 0, 0, 1],  # É o Lobo 2
    [1, 0, 1, 1, 0, 0],  # É o Lobo 3
    [0, 1, 0, 1, 1, 1],  # É a Vovó 1
    [0, 1, 0, 1, 1, 0],  # É a Vovó 2
    [0, 0, 0, 1, 1, 1],  # É a Vovó 3
    [1, 0, 0, 1, 1, 0],  # É a Vovó 4
    [1, 0, 0, 1, 1, 1],  # É a Vovó 5
    [0, 0, 0, 1, 0, 0],  # É o Lenhador 1
    [0, 0, 0, 1, 0, 1],  # É o Lenhador 2
    [0, 0, 0, 1, 1, 0]   # É o Lenhador 3
]
# Rótulos de treinamento (exemplo)
y_train = [
#    1  2  3  4  5  6  7
    [1, 1, 1, 0, 0, 0, 0],  # Rótulo para Lobo 1
    [1, 0, 1, 0, 0, 0, 0],  # Rótulo para Lobo 2
    [1, 1, 1, 0, 0, 0, 0],  # Rótulo para Lobo 3
    [0, 0, 0, 1, 1, 1, 0],  # Rótulo para Vovó 1
    [0, 0, 0, 0, 1, 1, 0],  # Rótulo para Vovó 2
    [0, 0, 0, 0, 1, 1, 0],  # Rótulo para Vovó 3
    [0, 0, 0, 0, 1, 1, 0],  # Rótulo para Vovó 4
    [0, 0, 0, 1, 1, 1, 0],  # Rótulo para Vovó 5
    [0, 0, 0, 0, 1, 0, 1],  # Rótulo para Lenhador 1
    [0, 0, 0, 1, 1, 1, 1],  # Rótulo para Lenhador 2
    [0, 0, 0, 0, 1, 0, 0]   # Rótulo para Lenhador 3
]
# Listas para armazenar as métricas de treinamento
loss_history = []
accuracy_history = []
# Função de callback para atualizar o gráfico a cada época
class TrainingPlot(tf.keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        # Inicializa a figura
        plt.ion()  # Ativa o modo interativo do matplotlib
        self.fig, (self.ax1, self.ax2) = plt.subplots(2, 1, figsize=(8, 6))
        self.fig.suptitle('Evolução do Treinamento')
        self.ax1.set_ylabel('Loss')
        self.ax2.set_ylabel('Accuracy')
        self.ax2.set_xlabel('Epoch')
        self.loss_line, = self.ax1.plot([], [], 'm-', label='Loss')
        self.accuracy_line, = self.ax2.plot([], [], 'b-', label='Accuracy')
        self.ax1.legend()
        self.ax2.legend()
        plt.show()
    def on_epoch_end(self, epoch, logs={}):
        # Atualiza as listas de métricas
        loss_history.append(logs.get('loss'))
        accuracy_history.append(logs.get('accuracy'))
        # Atualiza os dados do gráfico
        self.loss_line.set_data(range(len(loss_history)), loss_history)
        self.accuracy_line.set_data(range(len(accuracy_history)), accuracy_history)
        # Ajusta os limites dos eixos
        self.ax1.relim()
        self.ax1.autoscale_view()
        self.ax2.relim()
        self.ax2.autoscale_view()
        # Redesenha a figura
        self.fig.canvas.draw()
        plt.pause(0.1)  # Pausa para atualizar a janela gráfica
# Criando uma instância do callback
plot_callback = TrainingPlot()
# Solicita ao usuário o número de épocas
try:
    epochs = int(input("Digite o número de épocas desejadas: "))
except ValueError:
    print("Entrada inválida. Usando o valor padrão de 50 épocas.")
    epochs = 50  # Valor padrão caso o usuário insira algo inválido
# Medindo o tempo de processamento do treinamento
start_time = time.time()  # Captura o tempo inicial
# Treinando o modelo
# model.fit(X_train, y_train, epochs=100, batch_size=1)
# Treinando o modelo com o callback
model.fit(X_train, y_train, epochs=epochs, batch_size=1, verbose=0, callbacks=[plot_callback])
end_time = time.time()  # Captura o tempo final
training_time = end_time - start_time  # Calcula o tempo total de treinamento
# Exibindo o tempo de processamento
print(f"\nTempo de processamento do treinamento: {training_time:.2f} segundos")
# Fazendo previsões
predictions = model.predict(X_train)
## Exibindo resultados
""" Saída mais "simples"
# Exibindo previsões com labels
for i, pred in enumerate(predictions):
    print(f"Exemplo {i + 1}:")
    for j, value in enumerate(pred):
        bar = bargraph(value)  # Gera a barra de caracteres
        # print(f"  {output_labels[j]}: {value:.4f}")
        print(f"  {output_labels[j]}: {value:.4f} | {bar}")
"""
# Exibindo as previsões com barras de caracteres e entradas ativadas
for i, (input_data, pred) in enumerate(zip(X_train, predictions)):
    print(f"Exemplo {i + 1}:")
    # Exibe os labels das entradas ativadas
    activated = activated_inputs(input_data, input_labels)
    print(f"  Entradas ativadas: {activated}")
    # Exibe as saídas com barras de caracteres e formatação alinhada
    for j, value in enumerate(pred):
        bar = bargraph(value)  # Gera a barra de caracteres
        # print(f"  {output_labels[j]}: {value:.4f} | {bar}")
        # Formata o label da saída para ocupar o mesmo espaço que o maior label de entrada
        formatted_label = output_labels[j].ljust(max_input_label_length)       
        print(f"  {formatted_label}: {value:.4f} | {bar}")
# Congelando a janela gráfica até que o usuário pressione Enter
plt.ioff()  # Desativa o modo interativo
'''
plt.show(block=True)  # Mantém a janela gráfica aberta
Erro:
plt.show(block=True) bloqueia a execução do código até que a janela gráfica seja 
fechada manualmente, e o input() não é alcançado até que isso aconteça.
A solução é usar plt.pause() em vez de plt.show(block=True) e garantir que o 
input() seja alcançado após o treinamento.
Durante o treinamento, plt.pause(0.1) é usado para atualizar a janela gráfica a cada época.
Após o treinamento, o modo interativo é desativado com plt.ioff().
'''
print("\nPressione Enter para fechar a janela gráfica...")
input()  # Aguarda o usuário pressionar Enter
plt.close()  # Fecha a janela gráfica

Saída gerada


xxxxxxxxxx
(tf2.10) fernandopassold@MacBook-Pro-de-Fernando [00:07:02] [/Volumes/DADOS/Users/fpassold/Documents/IA/2025/RNs/Red] 
-> % python red_version_3.py
2025-03-18 00:07:05.246789: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2025-03-18 00:07:09.304129: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 3)                 21        
                                                                 
 dense_1 (Dense)             (None, 7)                 28        
                                                                 
=================================================================
Total params: 49
Trainable params: 49
Non-trainable params: 0
_________________________________________________________________
Epoch 1/10
11/11 [==============================] - 0s 808us/step - loss: 0.8045 - accuracy: 0.0909
Epoch 2/10
11/11 [==============================] - 0s 1ms/step - loss: 0.7971 - accuracy: 0.0909
Epoch 3/10
11/11 [==============================] - 0s 1ms/step - loss: 0.7898 - accuracy: 0.0909
Epoch 4/10
11/11 [==============================] - 0s 962us/step - loss: 0.7828 - accuracy: 0.0909
Epoch 5/10
11/11 [==============================] - 0s 935us/step - loss: 0.7766 - accuracy: 0.0909
Epoch 6/10
11/11 [==============================] - 0s 846us/step - loss: 0.7702 - accuracy: 0.0909
Epoch 7/10
11/11 [==============================] - 0s 848us/step - loss: 0.7637 - accuracy: 0.0909
Epoch 8/10
11/11 [==============================] - 0s 797us/step - loss: 0.7588 - accuracy: 0.0909
Epoch 9/10
11/11 [==============================] - 0s 870us/step - loss: 0.7528 - accuracy: 0.0909
Epoch 10/10
11/11 [==============================] - 0s 777us/step - loss: 0.7474 - accuracy: 0.0909
1/1 [==============================] - 0s 91ms/step
Exemplo 1:
  Entradas ativadas: 1. Grandes orelhas, 2. Grandes olhos, 3. Grandes dentes
  1. Fugir                 : 0.5836 | ######
  2. Gritar                : 0.4964 | #####
  3. Procurar pelo lenhador: 0.5709 | ######
  4. Beijar na bochecha    : 0.5847 | ######
  5. Aproximar-se          : 0.5923 | ######
  6. Oferecer comida       : 0.5780 | ######
  7. Flertar               : 0.4983 | #####
Exemplo 2:
  Entradas ativadas: 1. Grandes orelhas, 2. Grandes olhos, 3. Grandes dentes, 6. Bonito
  1. Fugir                 : 0.5945 | ######
  2. Gritar                : 0.4938 | #####
  3. Procurar pelo lenhador: 0.5818 | ######
  4. Beijar na bochecha    : 0.5961 | ######
  5. Aproximar-se          : 0.5983 | ######
  6. Oferecer comida       : 0.5826 | ######
  7. Flertar               : 0.5061 | #####
Exemplo 3:
  Entradas ativadas: 1. Grandes orelhas, 3. Grandes dentes, 4. Gentil
  1. Fugir                 : 0.5873 | ######
  2. Gritar                : 0.5158 | #####
  3. Procurar pelo lenhador: 0.6007 | ######
  4. Beijar na bochecha    : 0.5956 | ######
  5. Aproximar-se          : 0.6002 | ######
  6. Oferecer comida       : 0.6137 | ######
  7. Flertar               : 0.5573 | ######
Exemplo 4:
  Entradas ativadas: 2. Grandes olhos, 4. Gentil, 5. Enrugado, 6. Bonito
  1. Fugir                 : 0.6329 | ######
  2. Gritar                : 0.4791 | #####
  3. Procurar pelo lenhador: 0.6214 | ######
  4. Beijar na bochecha    : 0.6368 | ######
  5. Aproximar-se          : 0.6166 | ######
  6. Oferecer comida       : 0.5933 | ######
  7. Flertar               : 0.5390 | #####
Exemplo 5:
  Entradas ativadas: 2. Grandes olhos, 4. Gentil, 5. Enrugado
  1. Fugir                 : 0.6193 | ######
  2. Gritar                : 0.4831 | #####
  3. Procurar pelo lenhador: 0.6069 | ######
  4. Beijar na bochecha    : 0.6223 | ######
  5. Aproximar-se          : 0.6094 | ######
  6. Oferecer comida       : 0.5879 | ######
  7. Flertar               : 0.5269 | #####
Exemplo 6:
  Entradas ativadas: 4. Gentil, 5. Enrugado, 6. Bonito
  1. Fugir                 : 0.6172 | ######
  2. Gritar                : 0.4966 | #####
  3. Procurar pelo lenhador: 0.6296 | ######
  4. Beijar na bochecha    : 0.6269 | ######
  5. Aproximar-se          : 0.6097 | ######
  6. Oferecer comida       : 0.6125 | ######
  7. Flertar               : 0.5831 | ######
Exemplo 7:
  Entradas ativadas: 1. Grandes orelhas, 4. Gentil, 5. Enrugado
  1. Fugir                 : 0.5759 | ######
  2. Gritar                : 0.4969 | #####
  3. Procurar pelo lenhador: 0.5839 | ######
  4. Beijar na bochecha    : 0.5826 | ######
  5. Aproximar-se          : 0.5818 | ######
  6. Oferecer comida       : 0.5822 | ######
  7. Flertar               : 0.5464 | #####
Exemplo 8:
  Entradas ativadas: 1. Grandes orelhas, 4. Gentil, 5. Enrugado, 6. Bonito
  1. Fugir                 : 0.5902 | ######
  2. Gritar                : 0.4930 | #####
  3. Procurar pelo lenhador: 0.5987 | ######
  4. Beijar na bochecha    : 0.5977 | ######
  5. Aproximar-se          : 0.5893 | ######
  6. Oferecer comida       : 0.5879 | ######
  7. Flertar               : 0.5583 | ######
Exemplo 9:
  Entradas ativadas: 4. Gentil
  1. Fugir                 : 0.6140 | ######
  2. Gritar                : 0.5086 | #####
  3. Procurar pelo lenhador: 0.6359 | ######
  4. Beijar na bochecha    : 0.6261 | ######
  5. Aproximar-se          : 0.6123 | ######
  6. Oferecer comida       : 0.6278 | ######
  7. Flertar               : 0.5997 | ######
Exemplo 10:
  Entradas ativadas: 4. Gentil, 6. Bonito
  1. Fugir                 : 0.6271 | ######
  2. Gritar                : 0.5051 | #####
  3. Procurar pelo lenhador: 0.6492 | ######
  4. Beijar na bochecha    : 0.6399 | ######
  5. Aproximar-se          : 0.6194 | ######
  6. Oferecer comida       : 0.6332 | ######
  7. Flertar               : 0.6106 | ######
Exemplo 11:
  Entradas ativadas: 4. Gentil, 5. Enrugado
  1. Fugir                 : 0.6030 | ######
  2. Gritar                : 0.5005 | #####
  3. Procurar pelo lenhador: 0.6148 | ######
  4. Beijar na bochecha    : 0.6119 | ######
  5. Aproximar-se          : 0.6022 | ######
  6. Oferecer comida       : 0.6067 | ######
  7. Flertar               : 0.5709 | ######
(tf2.10) fernandopassold@MacBook-Pro-de-Fernando [00:07:10] [/Volumes/DADOS/Users/fpassold/Documents/IA/2025/RNs/Red] 
-> %

E ainda temos o gráfico que mostra a evolução do treinamento:

red_version_5

Obs.:

Note que este rede obteve seu melhor resultado pouco depois de 20 épocas de treinamento. Depois disto, a rede entrou num estado de overfitting. Isto significa que falta automatizar o treinamento acrescentando heurísticas (IF's encadeados) para automatizar o treinamento, reduzindo taxa de aprendizando, variando termo momentum, gravando pesos da rede toda vez que um novo melhor ponto de acertos seja alcançado e um arquivo texto de "log" deveria ser criado para informar o andamento do treinamento e nome dos arquivos de pesos gravados durante uma seção de treinamento. Também este script deveria ser incrementado para ler sempre o mesmo arquivo de pesos sinápticos inicializados (o estado de partida de uma rede pode influenciar o seu treinamento).

Resumo

A rede "Chapeuzinho Vermelho" foi corrigida para ter apenas uma camada oculta.
Labels foram associados às entradas e saídas para identificar o que cada ponto representa. Isso é feito durante o pré-processamento dos dados ou na exibição dos resultados.
O uso de labels não afeta o funcionamento do modelo, mas facilita a interpretação dos dados e resultados.

Hiperparâmetros da rede

Vamos esclarecer a diferença entre epochs e batch_size, dois hiperparâmetros fundamentais no treinamento de redes neurais. Ambos estão relacionados ao processo de aprendizado, mas desempenham papéis diferentes.

1. Epochs

O que é?
- Um epoch representa uma passagem completa pelo conjunto de dados de treinamento. Ou seja, quando o modelo vê todos os exemplos de treinamento uma vez, isso conta como 1 epoch.
Para que serve?
- O número de epochs define quantas vezes o modelo verá todo o conjunto de dados durante o treinamento.
- Um número maior de epochs permite que o modelo aprenda melhor os padrões dos dados, mas também aumenta o risco de overfitting (quando o modelo se ajusta demais aos dados de treinamento e perde a capacidade de generalizar para dados novos).
Exemplo prático:
- Se você tem 100 exemplos de treinamento e define epochs=10, o modelo verá os 100 exemplos 10 vezes durante o treinamento.

2. Batch Size

O que é?
- O batch size define o número de exemplos de treinamento que são processados antes de atualizar os pesos da rede.
- Em outras palavras, o modelo calcula o erro (perda) para um conjunto de exemplos (batch) e, em seguida, ajusta os pesos com base nesse erro.
Para que serve?
- Um batch size menor permite atualizações mais frequentes dos pesos, o que pode levar a um treinamento mais estável, mas também aumenta o tempo de treinamento.
- Um batch size maior processa mais exemplos de uma vez, o que pode acelerar o treinamento, mas pode levar a atualizações menos precisas dos pesos.
Exemplo prático:
- Se você tem 100 exemplos de treinamento e define batch_size=10, o modelo processará 10 exemplos por vez, calculará o erro médio para esses 10 exemplos e atualizará os pesos. Isso será repetido 10 vezes (100 exemplos / 10 por batch) para completar 1 epoch.

3. Relação entre Epochs e Batch Size

iterações $\text{Iterações por epoch} = \dfrac{\text{Número total de exemplos}}{\text{Batch size}}$ $\text{Iterações totais} = \text{Iterações por epoch} \times \text{Número de epochs}$
Exemplo:
- Se você tem 100 exemplos, batch_size=10 e epochs=5:
  - Iterações por epoch = 100 / 10 = 10
  - Iterações totais = 10 × 5 = 50

4. Impacto no Treinamento

Epochs:
- Poucos epochs podem resultar em underfitting (o modelo não aprende o suficiente).
- Muitos epochs podem resultar em overfitting (o modelo se ajusta demais aos dados de treinamento).
Batch Size:
- Um batch size pequeno pode levar a um treinamento mais lento, mas com atualizações mais precisas.
- Um batch size grande pode acelerar o treinamento, mas pode exigir mais memória e levar a atualizações menos precisas.

5. Como escolher os valores?

Epochs:
- Comece com um número moderado (por exemplo, 10) e observe a curva de aprendizado (perda no treinamento e validação).
- Se a perda no treinamento continuar diminuindo, aumente o número de epochs.
- Se a perda na validação começar a aumentar (sinal de overfitting), pare o treinamento ou use técnicas como early stopping.
Batch Size:
- Use um batch size que caiba na memória da sua GPU/CPU (por exemplo, 32, 64, 128).
- Para conjuntos de dados pequenos, um batch size menor pode funcionar melhor.
- Para conjuntos de dados grandes, um batch size maior pode acelerar o treinamento.

6. Aplicando ao seu código

No seu caso, o modelo pode não estar bem treinado porque:

O número de epochs pode ser insuficiente.
O batch size pode não ser adequado.
O conjunto de dados de treinamento pode ser muito pequeno.

Aqui está um exemplo de como ajustar esses parâmetros no seu código:


xxxxxxxxxx
# Treinando o modelo com mais epochs e um batch size adequado
model.fit(X_train, y_train, epochs=50, batch_size=2, verbose=1)

epochs=50: O modelo verá os dados de treinamento 50 vezes.
batch_size=2: O modelo processará 2 exemplos por vez antes de atualizar os pesos.
verbose=1: Exibe o progresso do treinamento.

7. Dicas para melhorar o treinamento

Aumente o número de epochs: Se a perda no treinamento ainda estiver diminuindo após o número atual de epochs, aumente esse valor.
Ajuste o batch size: Experimente valores como 2, 4, 8, 16, etc., e observe o impacto no treinamento.
Use early stopping: Interrompa o treinamento automaticamente se a perda na validação parar de melhorar.
Aumente o conjunto de dados: Se possível, use mais dados de treinamento para melhorar a generalização do modelo.

Resumo

Epochs: Número de vezes que o modelo vê todo o conjunto de dados.
Batch Size: Número de exemplos processados antes de atualizar os pesos.
Ajustar esses parâmetros é crucial para um treinamento eficiente e eficaz.

Segue para: Parte 3 (ainda não disponível)

17/03/2025