Rede Neural Usando TensorFlow: Classificação de Imagem

Olá Habr! Apresento a você a tradução do artigo "Treine sua primeira rede neural: classificação básica" .

Este é um guia de treinamento de modelo de rede neural para classificar imagens de roupas como tênis e camisas. Para criar uma rede neural, usamos python e a biblioteca TensorFlow.

Instale o TensorFlow

Para o trabalho, precisamos das seguintes bibliotecas:

1. numpy (na linha de comando que escrevemos: pip install numpy)
2. matplotlib (na linha de comando que escrevemos: pip install matplotlib)
3. keras (na linha de comando que escrevemos: pip install keras)
4. jupyter (na linha de comando que escrevemos: pip install jupyter)

Usando pip: na linha de comando, escreva pip install tensorflow
Se você receber um erro, poderá fazer o download do arquivo .whl e instalar usando pip: pip install file_path \ file_name.whl

Guia de instalação oficial do TensorFlow
Inicie o Jupyter. Para iniciar na linha de comando, escreva o bloco de anotações jupyter.

Introdução

#  import tensorflow as tf from tensorflow import keras import numpy as np import matplotlib.pyplot as plt 

Este guia usa o conjunto de dados Fashion MNIST, que contém 70.000 imagens em escala de cinza em 10 categorias. As imagens mostram roupas individuais com baixa resolução (28 por 28 pixels):

Usaremos 60.000 imagens para treinar a rede e 10.000 imagens para avaliar a precisão com que a rede aprendeu a classificar imagens. Você pode acessar o Fashion MNIST diretamente do TensorFlow simplesmente importando e baixando dados:

 fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data() 

O carregamento de um conjunto de dados retorna quatro matrizes NumPy:

1. As matrizes train_images e train_labels são os dados que o modelo usa para treinamento
2. As matrizes test_images e test_labels são usadas para testar o modelo.

As imagens são matrizes NumPy 28x28 cujos valores de pixel variam de 0 a 255. Os rótulos são uma matriz de números inteiros de 0 a 9. Eles correspondem à classe de vestuário:

Os nomes das classes não estão incluídos no conjunto de dados, portanto, nós os prescrevemos:

 class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'] 

Exploração de dados

Considere o formato do conjunto de dados antes de treinar o modelo.

 train_images.shape #    60 000 ,     28 x 28  test_images.shape #    10 000 ,     28 x 28  len(train_labels) #   60 000  len(test_labels) #   10 000  train_labels #       0  9 (  3    3 ) 

Pré-processamento de dados

Antes de preparar o modelo, os dados devem ser pré-processados. Se você verificar a primeira imagem no conjunto de treinamento, verá que os valores de pixel estão no intervalo de 0 a 255:

 plt.figure() plt.imshow(train_images[0]) plt.colorbar() plt.grid(False) 

Escalamos esses valores para um intervalo de 0 a 1:

 train_images = train_images / 255.0 test_images = test_images / 255.0 

Exibimos as 25 primeiras imagens do conjunto de treinamento e mostramos o nome da turma em cada imagem. Verifique se os dados estão no formato correto.

 plt.figure(figsize=(10,10)) for i in range(25): plt.subplot(5,5,i+1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(train_images[i], cmap=plt.cm.binary) plt.xlabel(class_names[train_labels[i]]) 

Construção de modelo

Construir uma rede neural requer camadas de ajuste do modelo.

O principal componente da rede neural é a camada. A maior parte do aprendizado profundo consiste em combinar camadas simples. A maioria das camadas, como tf.keras.layers.Dense, possui parâmetros que são aprendidos durante o treinamento.

 model = keras.Sequential([ keras.layers.Flatten(input_shape=(28, 28)), keras.layers.Dense(128, activation=tf.nn.relu), keras.layers.Dense(10, activation=tf.nn.softmax) ]) 

A primeira camada da rede tf.keras.layers.Flatten converte o formato da imagem de uma matriz 2D (28 por 28 pixels) em uma matriz 2D de 28 * 28 = 784 pixels. Esta camada não possui parâmetros para estudar, apenas reformata os dados.

As próximas duas camadas são tf.keras.layers.Dense. São camadas neurais firmemente conectadas ou totalmente conectadas. A primeira camada densa contém 128 nós (ou neurônios). O segundo (e último) nível é uma camada com 10 nós tf.nn.softmax, que retorna uma matriz de dez estimativas de probabilidade, cuja soma é 1. Cada nó contém uma estimativa que indica a probabilidade de a imagem atual pertencer a uma das 10 classes.

Compilando um modelo

Antes de o modelo estar pronto para o treinamento, serão necessárias mais algumas configurações. Eles são adicionados durante a fase de compilação do modelo:

• Função de perda - mede a precisão do modelo durante o treinamento
• Otimizador é como o modelo é atualizado com base nos dados que vê e na função de perda.
• Métricas (métricas) - usadas para controlar os estágios do treinamento e teste

 model.compile(optimizer=tf.train.AdamOptimizer(), loss='sparse_categorical_crossentropy', metrics=['accuracy']) 

Modelo de treinamento

Aprender um modelo de rede neural requer as seguintes etapas:

1. Envio de dados de treinamento do modelo (neste exemplo, matrizes train_images e train_labels)
2. Um modelo aprende a associar imagens e tags.
3. Pedimos ao modelo que faça previsões sobre o conjunto de testes (neste exemplo, a matriz test_images). Verificamos a conformidade das previsões de etiquetas da matriz de etiquetas (neste exemplo, a matriz test_labels)

Para iniciar o treinamento, chame o método model.fit:

 model.fit(train_images, train_labels, epochs=5) 

Ao modelar o modelo, os indicadores de perda (perda) e precisão (acc) são exibidos. Este modelo atinge uma precisão de cerca de 0,88 (ou 88%) de acordo com os dados de treinamento.

Classificação de precisão

Compare como o modelo funciona em um conjunto de dados de teste:

 test_loss, test_acc = model.evaluate(test_images, test_labels) print('Test accuracy:', test_acc) 

Acontece que a precisão no conjunto de dados de teste é ligeiramente menor que a precisão no conjunto de dados de treinamento. Essa lacuna entre a precisão do treinamento e a precisão do teste é um exemplo de reciclagem. A reciclagem é quando um modelo de aprendizado de máquina funciona pior com novos dados do que com dados de treinamento.

Previsão

Usamos o modelo para prever algumas imagens.

 predictions = model.predict(test_images) 

Aqui, o modelo previu o rótulo para cada imagem no caso de teste. Vejamos a primeira previsão:

 predictions[0] 

A previsão é uma matriz de 10 números. Eles descrevem a “confiança” do modelo de que a imagem corresponde a cada um dos 10 itens de vestuário diferentes. Podemos ver qual rótulo tem o maior valor de confiança:

 np.argmax(predictions[0]) #9 

Portanto, o modelo está mais confiante de que esta imagem é Ankle boot (Ankle boots) ou class_names [9]. E podemos verificar o rótulo do teste para garantir que isso esteja correto:

 test_labels[0] #9 

Escreveremos funções para visualizar essas previsões.

 def plot_image(i, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[i], true_label[i], img[i] plt.grid(False) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binary) predicted_label = np.argmax(predictions_array) if predicted_label == true_label: color = 'blue' else: color = 'red' plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label], 100*np.max(predictions_array), class_names[true_label]), color=color) def plot_value_array(i, predictions_array, true_label): predictions_array, true_label = predictions_array[i], true_label[i] plt.grid(False) plt.xticks([]) plt.yticks([]) thisplot = plt.bar(range(10), predictions_array, color="#777777") plt.ylim([0, 1]) predicted_label = np.argmax(predictions_array) thisplot[predicted_label].set_color('red') thisplot[true_label].set_color('blue') 

Vejamos a 0ª imagem, previsões e uma série de previsões.

 i = 0 plt.figure(figsize=(6,3)) plt.subplot(1,2,1) plot_image(i, predictions, test_labels, test_images) plt.subplot(1,2,2) plot_value_array(i, predictions, test_labels) 

Vamos construir algumas imagens com suas previsões. Os rótulos de previsão corretos são azuis e os rótulos de previsão incorretos são vermelhos. Observe que isso pode estar errado, mesmo quando ele está muito confiante.

 num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figure(figsize=(2*2*num_cols, 2*num_rows)) for i in range(num_images): plt.subplot(num_rows, 2*num_cols, 2*i+1) plot_image(i, predictions, test_labels, test_images) plt.subplot(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, predictions, test_labels) 

Finalmente, usamos um modelo treinado para fazer uma previsão sobre uma única imagem.

 #       img = test_images[0] 

Os modelos Tf.keras são otimizados para fazer previsões para pacotes (lote) ou coleções (coleção). Portanto, apesar de usarmos uma única imagem, precisamos adicioná-la à lista:

 #   ,      img = (np.expand_dims (img, 0)) 

Previsão para imagem:

 predictions_single = model.predict(img) print(predictions_single) 

 plot_value_array(0, predictions_single, test_labels) _ = plt.xticks(range(10), class_names, rotation=45) 

 np.argmax(predictions_single[0]) 

Como antes, o modelo prevê o rótulo 9.

Se você tiver dúvidas, escreva nos comentários ou em mensagens privadas.