Rede Neural 1

# Importa a biblioteca numpy para operações matemáticas e manipulação de arrays
import numpy as np

# Importa o módulo pyplot da biblioteca matplotlib para criar gráficos
import matplotlib.pyplot as plt

# Importa LabelBinarizer para converter rótulos em formato one-hot encoding
from sklearn.preprocessing import LabelBinarizer

# Importa classification_report para gerar um relatório de classificação
from sklearn.metrics import classification_report

# Importa as classes necessárias da biblioteca Keras para criar e treinar o modelo de rede neural
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.datasets import mnist
from tensorflow.keras import backend as K

# Acessando o dataset MNIST
# O MNIST é um dataset amplamente utilizado com imagens de dígitos manuscritos (0-9) em escala de cinza de 28x28 pixels.
print('[INFO] accessing MNIST...')

# Carregando o dataset MNIST
# O dataset está dividido em dados de treino (trainX, trainY) e de teste (testX, testY).
# 'trainX' contém as imagens de treino, 'trainY' contém os rótulos correspondentes (0 a 9).
# 'testX' e 'testY' são usados para avaliar o modelo após o treinamento.
((trainX, trainY), (testX, testY)) = mnist.load_data()

# Convertendo as imagens de 28x28 pixels em vetores de 784 dimensões (28*28)
# O modelo espera que os dados de entrada sejam um vetor unidimensional, então transformamos cada imagem 28x28 em um vetor de 784 elementos.
trainX = trainX.reshape((trainX.shape[0], 28 * 28 * 1))
testX = testX.reshape((testX.shape[0], 28 * 28 * 1))

# Normalizando as imagens para valores entre 0 e 1
# As imagens originalmente têm valores de pixel entre 0 e 255. Normalizamos esses valores para o intervalo [0, 1] dividindo por 255,
# o que ajuda a rede neural a convergir mais rapidamente durante o treinamento.
trainX = trainX.astype('float32') / 255.0
testX = testX.astype('float32') / 255.0

# Convertendo os rótulos para o formato one-hot encoding
# Os rótulos originais são valores inteiros (0-9). Precisamos convertê-los em um formato "one-hot encoded",
# onde cada rótulo é representado como um vetor de zeros, com um único 1 na posição correspondente à classe (ex: 2 = [0,0,1,0,0,0,0,0,0,0]).
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)

# Construindo o modelo da rede neural (Sequencial, camada a camada)
# O modelo será uma rede neural "feedforward", em que os dados fluem da camada de entrada para a camada de saída sem loops.
model = Sequential()

# Primeira camada oculta com 256 neurônios, função de ativação 'sigmoid'
# A função de ativação 'sigmoid' é usada para introduzir não linearidade no modelo, permitindo que ele aprenda padrões mais complexos.
model.add(Dense(256, input_shape=(784,), activation='sigmoid'))

# Segunda camada oculta com 128 neurônios, também com 'sigmoid'
# Esta camada tem menos neurônios (128) que a anterior e usa a mesma função de ativação.
model.add(Dense(128, activation='sigmoid'))

# Camada de saída com 10 neurônios, uma para cada classe (0 a 9), usando softmax para classificação
# A função softmax transforma a saída em probabilidades, com a soma das probabilidades de todas as classes sendo 1.
# Isso facilita a escolha da classe com maior probabilidade como a previsão final do modelo.
model.add(Dense(10, activation='softmax'))

# Configurando o otimizador SGD (gradiente descendente estocástico) com uma taxa de aprendizado de 0.01
# O SGD ajusta os pesos do modelo gradualmente, minimizando a função de perda (categorical_crossentropy).
# A taxa de aprendizado (0.01) define o quão grandes são os ajustes dos pesos em cada iteração.
sgd = SGD(0.01)

# Compilando o modelo, usando 'categorical_crossentropy' como função de perda e acurácia como métrica
# 'categorical_crossentropy' é usada para problemas de classificação com várias classes.
# A métrica 'accuracy' mede a performance do modelo.
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

# Treinando o modelo com os dados de treino, validando com os dados de teste
# 'epochs' define o número de vezes que o modelo vera todo o conjunto de treino.
# 'batch_size' define quantas amostras são processadas antes de atualizar os pesos.
H = model.fit(trainX, trainY, validation_data=(testX, testY), epochs=20, batch_size=128)

# Fazendo previsões no conjunto de teste
# Após o treinamento, fazemos previsões no conjunto de teste para ver como o modelo performa
# em dados que ele nunca viu antes.
predictions = model.predict(testX, batch_size=128)

# Relatório de classificação com métricas de desempenho (precisão, recall, F1-score)
# O classification_report gera um resumo das principais métricas de desempenho,
# comparando as previsões do modelo com os rótulos reais.
print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=[str(x) for x in lb.classes_]))

# Plotando os gráficos de perda e acurácia ao longo das épocas
# Agora, vamos visualizar como a perda e a acurácia variam durante o treinamento.
# Isso ajuda a entender se o modelo está aprendendo ou superajustando (overfitting).
plt.style.use('ggplot')
plt.figure()

# Plota a perda de treino e validação
plt.plot(np.arange(0, 20), H.history['loss'], label='train_loss')
plt.plot(np.arange(0, 20), H.history['val_loss'], label='val_loss')

# Plota a acurácia de treino e validação
plt.plot(np.arange(0, 20), H.history['accuracy'], label='train_acc')
plt.plot(np.arange(0, 20), H.history['val_accuracy'], label='val_acc')

# Definindo o título e labels dos eixos
# Estes títulos e legendas nos ajudam a interpretar os gráficos gerados.
plt.title('Training Loss and Accuracy')
plt.xlabel('Epoch #')
plt.ylabel('Loss/Accuracy')
plt.legend()
plt.show()