Previsão de dígitos manuscritos usando CNN (Parte 1)

Taras Rumezhak em Tornando-se Humano: Artificial Intelligence Magazine Seguir Jul 7 · 4 min ler

Hoje estamos construindo um classificador de dígitos em tempo real com o Python. Primeiro de tudo, deixe-me mostrar o resultado. Aqui está o vídeo onde podemos ver que o usuário tenta escrever dígitos e rede neural convolucional prediz o resultado que podemos ver no canto superior direito.

Estamos usando o conjunto de dados MNIST para treinar nosso modelo CNN. Depois de importar a biblioteca Keras, podemos usar seu método para carregar o conjunto de dados MNIST. Aqui você pode ver como esses dígitos se parecem.

Trending AI Articles:

1. Notas do Livro de Aprendizagem Profunda, Capítulo 1

2. Notas do Livro de Aprendizagem Profunda, Capítulo 2

3. Máquinas Demonstram Autoconsciência

4. Workshop de Música Visual e Aprendizagem de Máquina para Crianças

Precisamos entender a forma e o formato de nossos dados para previsões futuras sobre o novo tipo de dados.

Vamos começar a construir nosso modelo. Nós devemos importar algumas bibliotecas primeiro.

 import numpy como np 
import matplotlib.pyplot como plt
% matplotlib inline
de keras.datasets import mnist
de keras.models import Sequential
de keras.layers importam denso
de keras.layers import Dropout
de keras.layers import Flatten
de keras.layers.convolutional import Conv2D
da importação de keras.layers.convolutional MaxPooling2D
de keras.utils import np_utils
de backend de importação de keras como K
K.set_image_dim_ordering ('th')

Existe um método mnist especial para carregar o conjunto de dados. Neste momento, também estamos dividindo nossos dados no trem e nos conjuntos de teste.

 (X_train, y_train), (X_test, y_test) = mnist.load_data () 

Agora o processamento das imagens começa. Devemos reformular as imagens conforme estão escritas no código abaixo e convertê-las para o tipo 'float32'. Então, estamos mudando nossos dados para nos tornarmos categóricos.

 X_train = X_train.reshape (X_train.shape [0], 1, 28, 28) .astype ('float32') 
X_test = X_test.reshape (X_test.shape [0], 1, 28, 28) .astype ('float32')
X_train = X_train / 255
X_test = X_test / 255
y_train = np_utils.to_categorical (y_train)
y_test = np_utils.to_categorical (y_test)
num_classes = y_test.shape [1]

Agora, a parte mais interessante. Vamos construir nosso modelo. Você pode ler mais sobre essas camadas em outro artigo sobre o modelo CNN.

 model = Sequential () 
model.add (Conv2D (30, (5, 5), input_shape = (1, 28, 28), ativação = 'relu'))
model.add (MaxPooling2D (pool_size = (2, 2)))
model.add (Conv2D (15, (3, 3), ativação = 'relu'))
model.add (MaxPooling2D (pool_size = (2, 2)))
model.add (Rejeição (0.2))
model.add (Flatten ())
model.add (denso (128, ativação = 'relu'))
model.add (denso (50, ativação = 'relu'))
model.add (denso (num_classes, activation = 'softmax'))

Compile o modelo.

 model.compile (loss = 'categorical_crossentropy', optimizer = 'adam', métricas = ['precisão']) 

O modelo está sendo treinado. Existem 10 épocas. O tempo estimado para cada um deles é de 95 segundos.

 Treinar em 60000 amostras, validar em 10000 amostras 
Época 1/10
60000/60000 [==============================] - 96s 2ms / passo - perda: 0,3678 - acc: 0,8838 - val_loss : 0,0773 - val_acc: 0,9764
Época 2/10
60000/60000 [==============================] - 95s 2ms / passo - perda: 0,0895 - acc: 0,9726 - val_loss : 0,0480 - val_acc: 0,9849
Época 3/10
60000/60000 [==============================] - 95s 2ms / passo - perda: 0,0676 - acc: 0,9785 - val_loss : 0,0399 - val_acc: 0,9866
Época 4/10
60000/60000 [==============================] - 97s 2ms / passo - perda: 0,0545 - acc: 0,9830 - val_loss : 0,0335 - val_acc: 0,9883
Época 5/10
60000/60000 [==============================] - 96s 2ms / passo - perda: 0,0465 - acc: 0,9856 - val_loss : 0,0308 - val_acc: 0,9893
Época 6/10
60000/60000 [==============================] - 96s 2ms / passo - perda: 0,0413 - acc: 0,9873 - val_loss : 0,0308 - val_acc: 0,9900
Época 7/10
60000/60000 [==============================] - 96s 2ms / passo - perda: 0,0368 - acc: 0,9878 - val_loss : 0,0251 - val_acc: 0,9918
Época 8/10
60000/60000 [==============================] - 95s 2ms / passo - perda: 0,0338 - acc: 0,9887 - val_loss : 0,0287 - val_acc: 0,9906
Época 9/10
60000/60000 [==============================] - 94s 2ms / passo - perda: 0,0307 - acc: 0,9900 - val_loss : 0,0243 - val_acc: 0,9917
Epoch 10/10
60000/60000 [==============================] - 94s 2ms / passo - perda: 0,0288 - acc: 0,9902 - val_loss : 0,0250 - val_acc: 0,9921

A seção final do código nesta parte é salvar nosso modelo CNN. Nós podemos facilmente fazer isso:

 model.save ("digit_recognition.model") 

Aqui podemos ver como nossas previsões funcionam. Aqui classificador é o nosso modelo. O dígito na imagem é sete e o modelo previu corretamente.

Na próxima parte, aprenderemos como criar um programa de interface do usuário para executar a classificação de dígitos em tempo real com o modelo que acabamos de criar.

Obrigado pela leitura. Aproveite o seu aprendizado!

Não se esqueça de nos dar o seu ?!