Esta página foi traduzida pela API Cloud Translation.
Switch to English

Início rápido do TensorFlow 2 para iniciantes

Ver em TensorFlow.org Executar no Google Colab Ver fonte no GitHub Download do caderno

Esta breve introdução usa o Keras para:

  1. Construa uma rede neural que classifique imagens.
  2. Treine essa rede neural.
  3. E, finalmente, avalie a precisão do modelo.

Este é um arquivo do bloco de anotações do Google Colaboratory . Os programas Python são executados diretamente no navegador - uma ótima maneira de aprender e usar o TensorFlow. Para seguir este tutorial, execute o bloco de anotações no Google Colab clicando no botão na parte superior desta página.

  1. No Colab, conecte-se a um tempo de execução do Python: No canto superior direito da barra de menus, selecione CONNECT .
  2. Execute todas as células de código do notebook: selecione Tempo de execução > Executar tudo .

Baixe e instale o TensorFlow 2. Importe o TensorFlow para o seu programa:

 import tensorflow as tf
 

Carregue e prepare o conjunto de dados MNIST . Converta as amostras de números inteiros em números de ponto flutuante:

 mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
 

Crie o modelo tf.keras.Sequential empilhando camadas. Escolha uma função otimizadora e de perda para treinamento:

 model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])
 

Para cada exemplo, o modelo retorna um vetor de pontuações " logits " ou " log-odds ", um para cada classe.

 predictions = model(x_train[:1]).numpy()
predictions
 
array([[-0.3065545 , -0.00943594,  0.23859422, -0.13252608,  0.36969152,
        -0.28855872,  0.0292829 , -0.2822464 , -0.0586548 , -0.07721718]],
      dtype=float32)

A função tf.nn.softmax converte esses logits em "probabilidades" para cada classe:

 tf.nn.softmax(predictions).numpy()
 
array([[0.07570947, 0.10190306, 0.13058862, 0.09010106, 0.14888132,
        0.07708427, 0.10592601, 0.07757238, 0.09700894, 0.09522483]],
      dtype=float32)

A perda losses.SparseCategoricalCrossentropy pega um vetor de logits e um índice True e retorna uma perda escalar para cada exemplo.

 loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
 

Essa perda é igual à probabilidade de log negativo da classe verdadeira: será zero se o modelo tiver certeza da classe correta.

Esse modelo não treinado fornece probabilidades próximas do aleatório (1/10 para cada classe), portanto a perda inicial deve ser próxima de -tf.log(1/10) ~= 2.3 .

 loss_fn(y_train[:1], predictions).numpy()
 
2.5628562
 model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])
 

O método Model.fit ajusta os parâmetros do modelo para minimizar a perda:

 model.fit(x_train, y_train, epochs=5)
 
Epoch 1/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2960 - accuracy: 0.9149
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1436 - accuracy: 0.9578
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1075 - accuracy: 0.9672
Epoch 4/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0894 - accuracy: 0.9735
Epoch 5/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0746 - accuracy: 0.9761

<tensorflow.python.keras.callbacks.History at 0x7fe581c63080>

O método Model.evaluate verifica o desempenho dos modelos, geralmente em um " conjunto de validação " ou " conjunto de teste ".

 model.evaluate(x_test,  y_test, verbose=2)
 
313/313 - 0s - loss: 0.0745 - accuracy: 0.9777

[0.07445686310529709, 0.9776999950408936]

O classificador de imagem agora é treinado para ~ 98% de precisão neste conjunto de dados. Para saber mais, leia os tutoriais do TensorFlow .

Se você deseja que seu modelo retorne uma probabilidade, você pode agrupar o modelo treinado e anexar o softmax a ele:

 probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])
 
 probability_model(x_test[:5])
 
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[7.01788183e-10, 1.95062988e-09, 6.19953823e-07, 1.50849773e-05,
        7.57292146e-12, 5.76910075e-09, 1.96748034e-14, 9.99984026e-01,
        9.85261916e-09, 1.99302747e-07],
       [4.35530971e-08, 1.14592891e-04, 9.99861240e-01, 9.73965234e-06,
        3.20526591e-12, 8.73546426e-08, 2.75639309e-06, 2.96351572e-12,
        1.14401955e-05, 4.75777295e-13],
       [2.71199042e-07, 9.98870552e-01, 6.05373098e-05, 3.54041481e-06,
        8.74234102e-05, 3.20018262e-06, 1.97975914e-05, 8.69767973e-04,
        6.85211344e-05, 1.63736640e-05],
       [9.99933243e-01, 7.17326554e-09, 1.11575264e-06, 9.96544358e-08,
        7.04651995e-07, 2.54394877e-06, 4.02110236e-05, 3.15770012e-06,
        3.56192828e-07, 1.86549223e-05],
       [1.89385651e-06, 6.30246633e-10, 7.92857245e-05, 1.43984906e-07,
        9.98600900e-01, 1.00546046e-07, 3.58496732e-06, 1.13453330e-04,
        7.99138093e-07, 1.19981833e-03]], dtype=float32)>