resolucao_machine_learning_i

Prévia do material em texto

ROTEIRO DE AULA PRÁTICA
MACHINE LEARNING I
1. Importar Bibliotecas e Carregar Dados
Primeiramente importaremos as bibliotecas necessárias e carregar os dados do MNIST. O MNIST é um conjunto de dados clássico para reconhecimento de dígitos manuscritos, contendo 60.000 imagens de treinamento e 10.000 imagens de teste.
# Importar bibliotecas
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt
# Carregar o conjunto de dados MNIST
(X_train, y_train), (X_test, y_test) = mnist.load_data()
2. Preparar os Dados
Normalização
As imagens do MNIST têm valores de pixel entre 0 e 255. Para melhorar o desempenho do modelo, normalizamos esses valores para o intervalo [0, 1].
# Normalizar os dados para melhorar o desempenho do modelo
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0
3. Conversão de Rótulos
Os rótulos (dígitos) precisam ser convertidos de inteiros para uma representação categórica (one-hot encoding), onde cada dígito é representado por um vetor de 10 posições.
# Converter os rótulos para uma representação categórica
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
4. Construir o Modelo MLP
Aqui, definimos a arquitetura do nosso modelo de rede neural. Vamos usar o `Sequential` do Keras, que permite construir o modelo camada por camada.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
# Definir a arquitetura do modelo MLP
model = Sequential()
model.add(Flatten(input_shape=(28, 28))) # Transformar a imagem 28x28 em vetor
model.add(Dense(128, activation='relu')) # Primeira camada oculta com 128 neurônios
model.add(Dense(64, activation='relu')) # Segunda camada oculta com 64 neurônios
model.add(Dense(10, activation='softmax')) # Camada de saída com 10 neurônios (um para cada dígito)
 5. Compilar o Modelo
Após definir a arquitetura, precisamos compilar o modelo, escolhendo um otimizador, uma função de perda e métricas de avaliação.
model.compile(optimizer='adam',
 loss='categorical_crossentropy',
 metrics=['accuracy'])
Optimizer: Usamos o Adam, que é eficiente e popular.
Loss function: A `categorical_crossentropy` é adequada para problemas de classificação múltipla.
Metrics: Vamos acompanhar a precisão (`accuracy`).
6. Treinar o Modelo
Agora treinamos o modelo usando os dados de treinamento. Especificamos o número de épocas e o tamanho do lote.
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.2)
Epochs: O número de vezes que o modelo verá todo o conjunto de treinamento.
Batch size: O número de amostras que o modelo usa para atualizar os pesos.
Validation split: Usamos 20% dos dados de treinamento para validação.
7. Avaliar o Modelo
Após o treinamento, avaliamos o modelo com os dados de teste para verificar sua precisão.
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Loss: {loss:.4f}, Accuracy: {accuracy:.4f}')
Isso nos dará uma ideia de como o modelo se comporta com dados que não foram vistos durante o treinamento.
8. Fazer Previsões
Finalmente, podemos usar o modelo treinado para fazer previsões e visualizar alguns resultados.
# Fazer previsões com novos dados
predictions = model.predict(X_test)
# Visualizar alguns resultados
for i in range(5):
 plt.imshow(X_test[i], cmap='gray')
 plt.title(f'Predição: {predictions[i].argmax()}, Real: {y_test[i].argmax()}')
 plt.axis('off')
 plt.show()
Aqui, usamos `argmax()` para obter a classe prevista e a classe real, e plotamos algumas imagens para verificar se as previsões estão corretas.
Visualizar resultados
Abaixo segue uma imagem plotada para a verificação das previsões realizadas.
Conclusão
Esse processo lhe dará um modelo MLP básico para classificar dígitos manuscritos usando o MNIST.
image5.png
image6.png
image7.png
image8.png
image9.png
image1.png
image2.png
image3.png
image4.png