Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Treinamento personalizado: passo a passo

Ver no TensorFlow.org Executar no Google Colab Ver fonte no GitHub Baixar caderno

Este guia de aprendizagem usos máquina para categorizar Iris flores por espécies. Ele usa o TensorFlow para:

  1. Construir um modelo,
  2. Treine este modelo em dados de exemplo e
  3. Use o modelo para fazer previsões sobre dados desconhecidos.

Programação TensorFlow

Este guia usa estes conceitos de alto nível do TensorFlow:

Este tutorial é estruturado como muitos programas TensorFlow:

  1. Importe e analise o conjunto de dados.
  2. Selecione o tipo de modelo.
  3. Treine o modelo.
  4. Avalie a eficácia do modelo.
  5. Use o modelo treinado para fazer previsões.

Programa de configuração

Configurar importações

Importe o TensorFlow e os outros módulos Python necessários. Por padrão, TensorFlow usa execução ansiosos para avaliar as operações imediatamente, retornando valores concretos em vez de criar um gráfico computacional que é executado mais tarde. Se você está acostumado a um REPL ou o python console interativo, isso parece familiar.

import os
import matplotlib.pyplot as plt
import tensorflow as tf
print("TensorFlow version: {}".format(tf.__version__))
print("Eager execution: {}".format(tf.executing_eagerly()))
TensorFlow version: 2.6.0
Eager execution: True

O problema de classificação da íris

Imagine que você seja um botânico em busca de uma maneira automatizada de categorizar cada flor de íris que encontrar. O aprendizado de máquina fornece muitos algoritmos para classificar flores estatisticamente. Por exemplo, um programa sofisticado de aprendizado de máquina poderia classificar flores com base em fotografias. As nossas ambições são mais modestas-estamos indo para classificar Iris flores com base no comprimento e largura de suas sépalas e pétalas .

O gênero Iris envolve cerca de 300 espécies, mas nosso programa classificará apenas as três seguintes:

  • Iris setosa
  • Iris Virginica
  • Iris versicolor
Geometria da pétala comparada para três espécies de íris: Iris setosa, Iris virginica e Iris versicolor
Figura 1. setosa Íris (por Radomil , CC BY-SA 3,0), Iris versicolor , (por Dlanglois , CC BY-SA 3,0), e Iris virginica (por Frank Mayfield , CC BY-SA 2,0).

Felizmente, alguém já criou um conjunto de dados de 120 flores da íris com a sépala e medições pétalas. Este é um conjunto de dados clássico popular para problemas de classificação de aprendizado de máquina para iniciantes.

Importar e analisar o conjunto de dados de treinamento

Baixe o arquivo do conjunto de dados e converta-o em uma estrutura que possa ser usada por este programa Python.

Baixe o conjunto de dados

Baixe o arquivo de treinamento conjunto de dados usando o tf.keras.utils.get_file função. Isso retorna o caminho do arquivo baixado:

train_dataset_url = "https://storage.googleapis.com/download.tensorflow.org/data/iris_training.csv"

train_dataset_fp = tf.keras.utils.get_file(fname=os.path.basename(train_dataset_url),
                                           origin=train_dataset_url)

print("Local copy of the dataset file: {}".format(train_dataset_fp))
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/iris_training.csv
16384/2194 [================================================================================================================================================================================================================================] - 0s 0us/step
Local copy of the dataset file: /home/kbuilder/.keras/datasets/iris_training.csv

Inspecione os dados

Este conjunto de dados, iris_training.csv , é um arquivo de texto simples que armazena dados tabulares formatado como valores separados por vírgulas (CSV). Use a head -n5 comando para dar uma olhada nas cinco primeiras entradas:

head -n5 {train_dataset_fp}
120,4,setosa,versicolor,virginica
6.4,2.8,5.6,2.2,2
5.0,2.3,3.3,1.0,1
4.9,2.5,4.5,1.7,2
4.9,3.1,1.5,0.1,0

Nesta visão do conjunto de dados, observe o seguinte:

  1. A primeira linha é um cabeçalho contendo informações sobre o conjunto de dados:
    • Existem 120 exemplos no total. Cada exemplo tem quatro recursos e um dos três nomes de rótulos possíveis.
  2. Linhas subsequentes são registos de dados, um exemplo por linha, onde:
    • Os quatro primeiros campos são características : estas são as características de um exemplo. Aqui, os campos contêm números flutuantes que representam as medidas das flores.
    • A última coluna é o rótulo : este é o valor que queremos prever. Para este conjunto de dados, é um valor inteiro de 0, 1 ou 2 que corresponde a um nome de flor.

Vamos escrever isso em código:

# column order in CSV file
column_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']

feature_names = column_names[:-1]
label_name = column_names[-1]

print("Features: {}".format(feature_names))
print("Label: {}".format(label_name))
Features: ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
Label: species

Cada rótulo é associado ao nome da string (por exemplo, "setosa"), mas o aprendizado de máquina normalmente depende de valores numéricos. Os números dos rótulos são mapeados para uma representação nomeada, como:

  • 0 : Iris setosa
  • 1 : Iris versicolor
  • 2 : íris virginica

Para mais informações sobre os recursos e etiquetas, consulte a secção ML Terminologia do Bater Curso Machine Learning .

class_names = ['Iris setosa', 'Iris versicolor', 'Iris virginica']

Criar um tf.data.Dataset

De TensorFlow Conjunto de Dados da API lida com muitos casos comuns para carregar dados em um modelo. Esta é uma API de alto nível para ler dados e transformá-los em um formulário usado para treinamento.

Uma vez que o conjunto de dados é um arquivo de texto formatado-CSV, use o tf.data.experimental.make_csv_dataset função para analisar os dados em um formato adequado. Desde esta função gera dados para modelos de formação, o comportamento padrão é para baralhar os dados ( shuffle=True, shuffle_buffer_size=10000 ), e repetir o conjunto de dados para sempre ( num_epochs=None ). Nós também definir o batch_size parâmetro:

batch_size = 32

train_dataset = tf.data.experimental.make_csv_dataset(
    train_dataset_fp,
    batch_size,
    column_names=column_names,
    label_name=label_name,
    num_epochs=1)

Os make_csv_dataset função retorna um tf.data.Dataset de (features, label) pares, onde features é um dicionário: {'feature_name': value}

Estes Dataset objetos são iterable. Vejamos um lote de recursos:

features, labels = next(iter(train_dataset))

print(features)
OrderedDict([('sepal_length', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([4.6, 4.5, 7. , 4.9, 6.7, 5.4, 6.2, 5.9, 6.3, 6.4, 6.1, 5.3, 4.6,
       6.5, 5.1, 5.2, 5.6, 4.7, 5.2, 4.4, 4.9, 6.4, 6.8, 6.9, 4.8, 7.6,

       6. , 4.8, 5.4, 6.1, 5.1, 5.4], dtype=float32)>), ('sepal_width', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([3.1, 2.3, 3.2, 3. , 3. , 3.7, 2.2, 3. , 3.3, 2.8, 2.6, 3.7, 3.2,
       2.8, 3.8, 3.4, 2.9, 3.2, 2.7, 3. , 3.1, 3.2, 3.2, 3.2, 3.4, 3. ,
       2.2, 3. , 3.9, 2.8, 3.7, 3.4], dtype=float32)>), ('petal_length', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([1.5, 1.3, 4.7, 1.4, 5. , 1.5, 4.5, 5.1, 6. , 5.6, 5.6, 1.5, 1.4,
       4.6, 1.5, 1.4, 3.6, 1.3, 3.9, 1.3, 1.5, 4.5, 5.9, 5.7, 1.6, 6.6,
       5. , 1.4, 1.3, 4.7, 1.5, 1.5], dtype=float32)>), ('petal_width', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([0.2, 0.3, 1.4, 0.2, 1.7, 0.2, 1.5, 1.8, 2.5, 2.1, 1.4, 0.2, 0.2,
       1.5, 0.3, 0.2, 1.3, 0.2, 1.4, 0.2, 0.1, 1.5, 2.3, 2.3, 0.2, 2.1,
       1.5, 0.3, 0.4, 1.2, 0.4, 0.4], dtype=float32)>)])

Observe que like-recursos são agrupados, ou em lote. Os campos de cada linha de exemplo são anexados à matriz de recurso correspondente. Alterar o batch_size para definir o número de exemplos armazenados nessas matrizes metragens.

Você pode começar a ver alguns clusters traçando alguns recursos do lote:

plt.scatter(features['petal_length'],
            features['sepal_length'],
            c=labels,
            cmap='viridis')

plt.xlabel("Petal length")
plt.ylabel("Sepal length")
plt.show()

png

Para simplificar o passo de construção do modelo, criar uma função para remontar as características do dicionário para uma única matriz com a forma: (batch_size, num_features) .

Esta função utiliza o tf.stack método que toma valores a partir de uma lista de tensores e cria um tensor combinado na dimensão especificada:

def pack_features_vector(features, labels):
  """Pack the features into a single array."""
  features = tf.stack(list(features.values()), axis=1)
  return features, labels

Em seguida, use o tf.data.Dataset#map método para embalar as features de cada um (features,label) par para o conjunto de dados de treinamento:

train_dataset = train_dataset.map(pack_features_vector)

O elemento características do Dataset são agora matrizes com forma (batch_size, num_features) . Vejamos os primeiros exemplos:

features, labels = next(iter(train_dataset))

print(features[:5])
tf.Tensor(
[[6.7 3.1 4.4 1.4]
 [6.8 2.8 4.8 1.4]
 [5.  3.4 1.5 0.2]
 [7.4 2.8 6.1 1.9]
 [4.5 2.3 1.3 0.3]], shape=(5, 4), dtype=float32)

Selecione o tipo de modelo

Por que modelo?

Um modelo é uma relação entre as características e o rótulo. Para o problema de classificação da íris, o modelo define a relação entre as medidas das sépalas e pétalas e as espécies preditas de íris. Alguns modelos simples podem ser descritos com algumas linhas de álgebra, mas modelos complexos de aprendizado de máquina têm um grande número de parâmetros que são difíceis de resumir.

Você poderia determinar a relação entre as quatro características e as espécies da íris sem o uso de aprendizagem de máquina? Ou seja, você poderia usar técnicas de programação tradicionais (por exemplo, muitas instruções condicionais) para criar um modelo? Talvez - se você analisou o conjunto de dados por tempo suficiente para determinar as relações entre as medições das pétalas e sépalas para uma espécie em particular. E isso se torna difícil - talvez impossível - em conjuntos de dados mais complicados. A abordagem de aprendizagem boa máquina determina o modelo para você. Se você inserir exemplos representativos suficientes no tipo certo de modelo de aprendizado de máquina, o programa descobrirá os relacionamentos para você.

Selecione o modelo

Precisamos selecionar o tipo de modelo a treinar. Existem muitos tipos de modelos e escolher um bom exige experiência. Este tutorial usa uma rede neural para resolver o problema de classificação de íris. As redes neurais podem encontrar relações complexas entre recursos e o rótulo. É um gráfico altamente estruturada, organizados em uma ou mais camadas escondidas . Cada camada escondida é constituído por um ou mais neurónios . Existem várias categorias de redes neurais e este programa utiliza uma densa ou rede neural totalmente conectado : os neurônios em uma camada receber conexões de entrada de cada neurônio na camada anterior. Por exemplo, a Figura 2 ilustra uma rede neural densa que consiste em uma camada de entrada, duas camadas ocultas e uma camada de saída:

Um diagrama da arquitetura da rede: entradas, 2 camadas ocultas e saídas
Figura 2. Uma rede neural com características, camadas ocultas e previsões.

Quando o modelo da Figura 2 é treinado e alimentado com um exemplo não rotulado, ele produz três previsões: a probabilidade de que essa flor seja a espécie de íris fornecida. Essa previsão é chamado de inferência . Para este exemplo, a soma das previsões de saída é 1,0. Na Figura 2, esta previsão reparte-se: 0.02 para íri, 0.95 para Iris versicolor, e 0.03 para Iris virginica. Isto significa que o modelo prevê-com 95% de probabilidade de que um exemplo-flor não marcado é um versicolor da íris.

Crie um modelo usando Keras

O TensorFlow tf.keras API é a forma preferida para criar modelos e camadas. Isso torna mais fácil construir modelos e experimentar enquanto Keras lida com a complexidade de conectar tudo junto.

O tf.keras.Sequential modelo é uma pilha de camadas linear. Seu construtor tem uma lista de exemplos de camada, neste caso, dois tf.keras.layers.Dense camadas com 10 nós cada, e uma camada de saída com 3 nós representam nossos previsões etiqueta. A primeira camada é input_shape corresponde parâmetro para o número de recursos do conjunto de dados, e é necessário:

model = tf.keras.Sequential([
  tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)),  # input shape required
  tf.keras.layers.Dense(10, activation=tf.nn.relu),
  tf.keras.layers.Dense(3)
])

A função de activação determina a forma de cada nó na camada de saída. Essas não linearidades são importantes - sem elas, o modelo seria equivalente a uma única camada. Há muitos tf.keras.activations , mas Relu é comum para as camadas ocultas.

O número ideal de camadas e neurônios ocultos depende do problema e do conjunto de dados. Como muitos aspectos do aprendizado de máquina, escolher a melhor forma da rede neural requer uma mistura de conhecimento e experimentação. Como regra geral, aumentar o número de camadas e neurônios ocultos normalmente cria um modelo mais poderoso, que requer mais dados para treinar com eficácia.

Usando o modelo

Vamos dar uma olhada rápida no que este modelo faz com um lote de recursos:

predictions = model(features)
predictions[:5]
<tf.Tensor: shape=(5, 3), dtype=float32, numpy=
array([[3.3970695 , 2.5164433 , 1.6042098 ],
       [3.5879614 , 2.7150419 , 1.7798408 ],
       [2.0230737 , 1.2138845 , 0.5435198 ],
       [4.1191735 , 3.1622481 , 2.1603928 ],
       [1.965474  , 1.2190092 , 0.54945964]], dtype=float32)>

Aqui, cada exemplo retorna uma logit para cada classe.

Para converter esses logits a uma probabilidade para cada classe, use o softmax função:

tf.nn.softmax(predictions[:5])
<tf.Tensor: shape=(5, 3), dtype=float32, numpy=
array([[0.6325084 , 0.26218945, 0.10530216],
       [0.6322343 , 0.26410332, 0.10366239],
       [0.5977436 , 0.26612675, 0.13612968],
       [0.6556937 , 0.25183356, 0.09247267],
       [0.5825066 , 0.27613106, 0.1413623 ]], dtype=float32)>

Tomando o tf.argmax em todas as classes nos dá o índice de classe previsível. Mas, o modelo ainda não foi treinado, então essas não são boas previsões:

print("Prediction: {}".format(tf.argmax(predictions, axis=1)))
print("    Labels: {}".format(labels))
Prediction: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
    Labels: [1 1 0 2 0 2 2 0 2 2 1 1 0 2 0 2 2 2 0 0 0 0 0 2 1 2 0 1 0 1 1 1]

Treine o modelo

Formação é a fase de aprendizado de máquina quando o modelo está gradualmente otimizada, ou o modelo aprende o conjunto de dados. O objetivo é aprender o suficiente sobre a estrutura do conjunto de dados de treinamento para fazer previsões sobre dados não vistos. Se você aprender muito sobre o conjunto de dados de treinamento, em seguida, as previsões só funcionam para os dados que ele tem visto e não vai ser generalizados. Este problema é chamado overfitting -É como memorizar as respostas ao invés de compreender a forma de resolver um problema.

O problema de classificação Iris é um exemplo de aprendizado de máquina supervisionado : o modelo é treinado a partir de exemplos que contêm rótulos. Na aprendizagem de máquina sem supervisão , os exemplos não contêm rótulos. Em vez disso, o modelo normalmente encontra padrões entre os recursos.

Defina a função de perda e gradiente

Ambos os estágios de treinamento e avaliação precisa calcular o modelo de perda . Isso mede o quanto as previsões de um modelo estão fora do rótulo desejado, em outras palavras, o quão ruim o modelo está se saindo. Queremos minimizar ou otimizar esse valor.

Nosso modelo irá calcular a sua perda usando o tf.keras.losses.SparseCategoricalCrossentropy função que leva as previsões de probabilidade de classe do modelo e o rótulo desejado, e retorna a perda média dos exemplos.

loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
def loss(model, x, y, training):
  # training=training is needed only if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  y_ = model(x, training=training)

  return loss_object(y_true=y, y_pred=y_)


l = loss(model, features, labels, training=False)
print("Loss test: {}".format(l))
Loss test: 1.3074543476104736

Use o tf.GradientTape contexto para calcular os gradientes utilizados para otimizar o seu modelo:

def grad(model, inputs, targets):
  with tf.GradientTape() as tape:
    loss_value = loss(model, inputs, targets, training=True)
  return loss_value, tape.gradient(loss_value, model.trainable_variables)

Crie um otimizador

Um otimizador aplica os gradientes calculados para variáveis do modelo para minimizar a loss função. Você pode pensar na função de perda como uma superfície curva (consulte a Figura 3) e queremos encontrar seu ponto mais baixo caminhando. Os gradientes apontam na direção da subida mais íngreme - portanto, viajaremos na direção oposta e desceremos a colina. Calculando iterativamente a perda e o gradiente de cada lote, ajustaremos o modelo durante o treinamento. Gradualmente, o modelo encontrará a melhor combinação de pesos e tendências para minimizar a perda. E quanto menor a perda, melhores são as previsões do modelo.

Algoritmos de otimização visualizados ao longo do tempo no espaço 3D.
Figura 3. Optimization algoritmos visualizados ao longo do tempo no espaço 3D.
(Fonte: Stanford classe CS231n , MIT License, Crédito da imagem: Alec Radford )

O TensorFlow tem muitos algoritmos de otimização disponíveis para treinamento. Este modelo usa o tf.keras.optimizers.SGD que implementa o gradiente descendente estocástico (SGD) algoritmo. O learning_rate define o tamanho do passo a tomar para cada iteração descendo a colina. Esta é uma hiperparâmetro que você vai comumente ajustar para alcançar melhores resultados.

Vamos configurar o otimizador:

optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

Usaremos isso para calcular uma única etapa de otimização:

loss_value, grads = grad(model, features, labels)

print("Step: {}, Initial Loss: {}".format(optimizer.iterations.numpy(),
                                          loss_value.numpy()))

optimizer.apply_gradients(zip(grads, model.trainable_variables))

print("Step: {},         Loss: {}".format(optimizer.iterations.numpy(),
                                          loss(model, features, labels, training=True).numpy()))
Step: 0, Initial Loss: 1.3074543476104736
Step: 1,         Loss: 1.2451764345169067

Loop de treinamento

Com todas as peças no lugar, a modelo está pronta para treinar! Um loop de treinamento alimenta os exemplos de conjuntos de dados no modelo para ajudá-lo a fazer melhores previsões. O bloco de código a seguir configura essas etapas de treinamento:

  1. Iterar cada época. Uma época é uma passagem pelo conjunto de dados.
  2. Dentro de uma época, iterar sobre cada exemplo na formação Dataset agarrando suas características ( x ) e etiqueta ( y ).
  3. Usando os recursos do exemplo, faça uma previsão e compare-a com o rótulo. Meça a imprecisão da previsão e use-a para calcular a perda e gradientes do modelo.
  4. Use um optimizer para atualizar as variáveis do modelo.
  5. Acompanhe algumas estatísticas para visualização.
  6. Repita para cada época.

O num_epochs variável é o número de vezes que a malha através da recolha do conjunto de dados. Contra-intuitivamente, treinar um modelo por mais tempo não garante um modelo melhor. num_epochs é um hiperparâmetro que você pode sintonizar. A escolha do número certo geralmente requer experiência e experimentação:

## Note: Rerunning this cell uses the same model variables

# Keep results for plotting
train_loss_results = []
train_accuracy_results = []

num_epochs = 201

for epoch in range(num_epochs):
  epoch_loss_avg = tf.keras.metrics.Mean()
  epoch_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()

  # Training loop - using batches of 32
  for x, y in train_dataset:
    # Optimize the model
    loss_value, grads = grad(model, x, y)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))

    # Track progress
    epoch_loss_avg.update_state(loss_value)  # Add current batch loss
    # Compare predicted label to actual label
    # training=True is needed only if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    epoch_accuracy.update_state(y, model(x, training=True))

  # End epoch
  train_loss_results.append(epoch_loss_avg.result())
  train_accuracy_results.append(epoch_accuracy.result())

  if epoch % 50 == 0:
    print("Epoch {:03d}: Loss: {:.3f}, Accuracy: {:.3%}".format(epoch,
                                                                epoch_loss_avg.result(),
                                                                epoch_accuracy.result()))
Epoch 000: Loss: 1.195, Accuracy: 35.000%
Epoch 050: Loss: 0.462, Accuracy: 86.667%
Epoch 100: Loss: 0.287, Accuracy: 93.333%
Epoch 150: Loss: 0.193, Accuracy: 98.333%
Epoch 200: Loss: 0.158, Accuracy: 97.500%

Visualize a função de perda ao longo do tempo

Embora seja útil para imprimir progresso do treinamento do modelo, muitas vezes é mais útil para ver este progresso. TensorBoard é uma ferramenta de visualização agradável que é empacotado com TensorFlow, mas podemos criar gráficos básicos usando o matplotlib módulo.

A interpretação desses gráficos tem alguma experiência, mas você realmente quer ver a perda descer e a precisão subir:

fig, axes = plt.subplots(2, sharex=True, figsize=(12, 8))
fig.suptitle('Training Metrics')

axes[0].set_ylabel("Loss", fontsize=14)
axes[0].plot(train_loss_results)

axes[1].set_ylabel("Accuracy", fontsize=14)
axes[1].set_xlabel("Epoch", fontsize=14)
axes[1].plot(train_accuracy_results)
plt.show()

png

Avalie a eficácia do modelo

Agora que o modelo está treinado, podemos obter algumas estatísticas sobre seu desempenho.

Avaliando os meios que determinam a eficácia do modelo faz previsões. Para determinar a eficácia do modelo na classificação da íris, passe algumas medidas de sépala e pétala para o modelo e peça ao modelo para prever quais espécies de íris elas representam. Em seguida, compare as previsões do modelo com o rótulo real. Por exemplo, um modelo que se obter as espécies correctas em metade dos exemplos de entrada tem uma precisão de 0.5 . A Figura 4 mostra um modelo um pouco mais eficaz, acertando 4 de 5 previsões com precisão de 80%:

Recursos de exemplo Rótulo Predição de modelo
5,9 3,0 4,3 1,5 1 1
6,9 3,1 5,4 2,1 2 2
5,1 3,3 1,7 0,5 0 0
6,0 3,4 4,5 1,6 1 2
5,5 2,5 4,0 1,3 1 1
Figura 4. Um Iris classificador que é de 80% de precisão.

Configure o conjunto de dados de teste

Avaliar o modelo é semelhante a treiná-lo. A maior diferença é os exemplos vêm de uma separado conjunto de teste em vez do conjunto de treinamento. Para avaliar de forma justa a eficácia de um modelo, os exemplos usados ​​para avaliar um modelo devem ser diferentes dos exemplos usados ​​para treinar o modelo.

A configuração para o teste Dataset é semelhante à configuração para treinar Dataset . Baixe o arquivo de texto CSV e analise esses valores, em seguida, embaralhe-o um pouco:

test_url = "https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv"

test_fp = tf.keras.utils.get_file(fname=os.path.basename(test_url),
                                  origin=test_url)
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv
16384/573 [=========================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 0s 0us/step
test_dataset = tf.data.experimental.make_csv_dataset(
    test_fp,
    batch_size,
    column_names=column_names,
    label_name='species',
    num_epochs=1,
    shuffle=False)

test_dataset = test_dataset.map(pack_features_vector)

Avalie o modelo no conjunto de dados de teste

Ao contrário da fase de treinamento, o modelo avalia apenas uma única época dos dados de teste. Na célula de código a seguir, iteramos sobre cada exemplo no conjunto de teste e comparamos a previsão do modelo com o rótulo real. Isso é usado para medir a precisão do modelo em todo o conjunto de teste:

test_accuracy = tf.keras.metrics.Accuracy()

for (x, y) in test_dataset:
  # training=False is needed only if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  logits = model(x, training=False)
  prediction = tf.argmax(logits, axis=1, output_type=tf.int32)
  test_accuracy(prediction, y)

print("Test set accuracy: {:.3%}".format(test_accuracy.result()))
Test set accuracy: 100.000%

Podemos ver no último lote, por exemplo, o modelo costuma estar correto:

tf.stack([y,prediction],axis=1)
<tf.Tensor: shape=(30, 2), dtype=int32, numpy=
array([[1, 1],
       [2, 2],
       [0, 0],
       [1, 1],
       [1, 1],
       [1, 1],
       [0, 0],
       [2, 2],
       [1, 1],
       [2, 2],
       [2, 2],
       [0, 0],
       [2, 2],
       [1, 1],
       [1, 1],
       [0, 0],
       [1, 1],
       [0, 0],
       [0, 0],
       [2, 2],
       [0, 0],
       [1, 1],
       [2, 2],
       [1, 1],
       [1, 1],
       [1, 1],
       [0, 0],
       [1, 1],
       [2, 2],
       [1, 1]], dtype=int32)>

Use o modelo treinado para fazer previsões

Treinamos um modelo e "provamos" que ele é bom - mas não perfeito - na classificação das espécies de íris. Agora vamos usar o modelo treinado para fazer algumas previsões sobre exemplos não marcados ; ou seja, em exemplos que contêm recursos, mas não um rótulo.

Na vida real, os exemplos não rotulados podem vir de muitas fontes diferentes, incluindo aplicativos, arquivos CSV e feeds de dados. Por enquanto, forneceremos manualmente três exemplos sem rótulos para prever seus rótulos. Lembre-se, os números dos rótulos são mapeados para uma representação nomeada como:

  • 0 : Iris setosa
  • 1 : Iris versicolor
  • 2 : íris virginica
predict_dataset = tf.convert_to_tensor([
    [5.1, 3.3, 1.7, 0.5,],
    [5.9, 3.0, 4.2, 1.5,],
    [6.9, 3.1, 5.4, 2.1]
])

# training=False is needed only if there are layers with different
# behavior during training versus inference (e.g. Dropout).
predictions = model(predict_dataset, training=False)

for i, logits in enumerate(predictions):
  class_idx = tf.argmax(logits).numpy()
  p = tf.nn.softmax(logits)[class_idx]
  name = class_names[class_idx]
  print("Example {} prediction: {} ({:4.1f}%)".format(i, name, 100*p))
Example 0 prediction: Iris setosa (97.6%)
Example 1 prediction: Iris versicolor (90.4%)
Example 2 prediction: Iris virginica (63.3%)