Começando com Keras

Se você é novo com Inteligência Artificial e seus correlatos (Machine Learning e Deep Learning) talvez esteja confuso como começar neste novo mundo. No Deep Learning existem muitos frameworks e bibliotecas populares como o Tensorflow, Caffe2, CNTK e Theano. Eu sempre recomendo começar com Keras porque é uma API de redes neurais de alto nível escrita em Python e capaz de rodar em cima de TensorFlow, CNTK ou Theano.

Neste post, você aprenderá a usar o Keras para criar uma rede neural que classifica o conjunto de dados MNIST com uma precisão de 97%. Você pode clonar este projeto aqui: https://github.com/waslleysouza/keras.

Se você estiver usando o Anaconda, crie um novo ambiente e instale o Keras.

conda create -n py36keras python=3.6 keras matplotlib nb_conda -y

Após a criação do ambiente, ative-o …

activate py36keras

E inicie o Notebook Jupyter.

jupyter notebook

O Jupyter é iniciado automaticamente.
Crie um novo notebook “Python [conda env: py36keras]”.

Agora somos capazes de codificar!
Primeiro de tudo importe a biblioteca Keras.

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import to_categorical
import matplotlib.pyplot as plt

Como você pode ver, nós importamos o conjunto de dados MNIST do Keras.
MNIST é um conjunto de dados de dígitos de 0 a 9 escritos à mão com imagens e rótulos.
Em seguida, vá e carregue o conjunto de dados.

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

Você pode ver a forma dos tensores.
Este conjunto de dados tem 60.000 imagens (28×28) e rótulos para treinar e 10.000 imagens (28×28) e rótulos para testar o seu modelo.

print(train_images.shape, train_labels.shape)
print(test_images.shape, test_labels.shape)

Vamos ver uma imagem.

plt.imshow(train_images[20], cmap='binary')
plt.show()

Pré-processe os dados, remodelando-os na forma esperada pela rede e dimensionando-os para que todos os valores estejam no intervalo [0, 1].

train_images = train_images.reshape((60000, 28*28))
train_images = train_images.astype('float32') / 255
test_images = test_images.reshape((10000, 28*28))
test_images = test_images.astype('float32') / 255

Vectorize os rótulos usando o one-hot encoding.

num_classes = 10
train_labels = to_categorical(train_labels, num_classes)
test_labels = to_categorical(test_labels, num_classes)

Crie uma rede simples com duas camadas totalmente conectadas.
A primeira camada Dense tem tamanho de 32 unidades e usa ativação relu.
A segunda camada Dense tem tamanho de 10 unidades e usa ativação softmax.

model = Sequential()
model.add(Dense(32, activation='relu', input_shape=(28*28,)))
model.add(Dense(num_classes, activation='softmax'))
model.summary()

Para finalizar, compile e treine a rede.

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
history = model.fit(train_images, train_labels, batch_size=64, epochs=10, validation_data=(test_images, test_labels))

Plote a comparação de accuracy e loss entre as etapas de treinamento e validação.

acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc)+1)

plt.plot(epochs, acc, 'bo', label='Training Accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation Accuracy')
plt.title('Training x Validation Accuracy')
plt.legend()
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.figure()

plt.plot(epochs, loss, 'bo', label='Training Loss')
plt.plot(epochs, val_loss, 'b', label='Validation Loss')
plt.title('Training x Validation Loss')
plt.legend()
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.show()

Feito! Você criou uma rede neural que classifica dígitos entre 0 e 9 com uma precisão de 97%.
Divirta-se!

Autor: Waslley Souza

Consultor Oracle com foco em tecnologias Oracle Fusion Middleware e SOA. Certificado Oracle WebCenter Portal, Oracle ADF e Java.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *