Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Entrenamiento personalizado: tutorial

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub Descargar cuaderno

Esta guía de aprendizaje automático usos para categorizar Iris Flores por especies. Utiliza TensorFlow para:

  1. Construir un modelo,
  2. Entrene este modelo con datos de ejemplo y
  3. Utilice el modelo para hacer predicciones sobre datos desconocidos.

Programación de TensorFlow

Esta guía utiliza estos conceptos de TensorFlow de alto nivel:

Este tutorial está estructurado como muchos programas de TensorFlow:

  1. Importe y analice el conjunto de datos.
  2. Seleccione el tipo de modelo.
  3. Entrena al modelo.
  4. Evalúe la efectividad del modelo.
  5. Utilice el modelo entrenado para hacer predicciones.

Programa de instalación

Configurar importaciones

Importa TensorFlow y los demás módulos de Python necesarios. Por defecto, utiliza TensorFlow ejecución ansiosos para evaluar las operaciones de inmediato, la devolución de valores concretos en lugar de crear un gráfico computacional que se ejecuta después. Si estás acostumbrado a un REPL o el python consola interactiva, esto le resulta 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

El problema de clasificación del iris

Imagina que eres un botánico que busca una forma automatizada de categorizar cada flor de Iris que encuentres. El aprendizaje automático proporciona muchos algoritmos para clasificar las flores estadísticamente. Por ejemplo, un sofisticado programa de aprendizaje automático podría clasificar las flores basándose en fotografías. Nuestras ambiciones son más modestos los vamos a clasificar las flores del diafragma en función de la longitud y la anchura de las mediciones de sus sépalos y pétalos .

El género Iris comprende alrededor de 300 especies, pero nuestro programa solo clasificará las siguientes tres:

  • Iris setosa
  • Iris virginica
  • Iris versicolor
Geometría de pétalos comparada para tres especies de iris: Iris setosa, Iris virginica e Iris versicolor
Figura 1. setosa Iris (por Radomil , CC BY-SA 3.0), Iris versicolor , (por Dlanglois , CC BY-SA 3.0), y virginica Iris (por Frank Mayfield , CC BY-SA 2.0).

Afortunadamente, alguien ya ha creado un conjunto de datos de 120 flores del iris con sépalo y pétalo mediciones. Este es un conjunto de datos clásico que es popular para problemas de clasificación de aprendizaje automático para principiantes.

Importar y analizar el conjunto de datos de entrenamiento

Descargue el archivo del conjunto de datos y conviértalo en una estructura que pueda usar este programa de Python.

Descarga el conjunto de datos

Descargar el archivo de entrenamiento conjunto de datos utilizando la tf.keras.utils.get_file función. Esto devuelve la ruta del archivo descargado:

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

Inspeccione los datos

Este conjunto de datos, iris_training.csv , es un archivo de texto que almacena los datos tabulares formateados como valores separados por comas (CSV). Usar la head -n5 comando para echar un vistazo a las primeras cinco 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

Desde esta vista del conjunto de datos, observe lo siguiente:

  1. La primera línea es un encabezado que contiene información sobre el conjunto de datos:
    • Hay 120 ejemplos en total. Cada ejemplo tiene cuatro características y uno de los tres posibles nombres de etiqueta.
  2. Las filas subsiguientes son registros de datos, uno ejemplo por línea, donde:
    • Los primeros cuatro campos son características : estas son las características de un ejemplo. Aquí, los campos contienen números flotantes que representan las medidas de las flores.
    • La última columna es la etiqueta : este es el valor que queremos predecir. Para este conjunto de datos, es un valor entero de 0, 1 o 2 que corresponde al nombre de una flor.

Escribamos eso en 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 etiqueta está asociada con un nombre de cadena (por ejemplo, "setosa"), pero el aprendizaje automático generalmente se basa en valores numéricos. Los números de etiqueta se asignan a una representación con nombre, como:

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

Para obtener más información acerca de las características y etiquetas, consulte la sección de ML Terminología del Curso acelerado de aprendizaje automático .

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

Crear un tf.data.Dataset

TensorFlow de la API del conjunto de datos maneja muchos casos comunes para cargar datos en un modelo. Se trata de una API de alto nivel para leer datos y transformarlos en un formulario utilizado para la formación.

Dado que el conjunto de datos es un archivo de texto CSV con formato, utilice el tf.data.experimental.make_csv_dataset función para analizar los datos en un formato adecuado. Dado que esta función genera datos para los modelos de formación, el comportamiento por defecto es que barajar los datos ( shuffle=True, shuffle_buffer_size=10000 ), y repetir el conjunto de datos para siempre ( num_epochs=None ). También establecemos el 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)

Los make_csv_dataset función devuelve un tf.data.Dataset de (features, label) pares, en los que features es un diccionario: {'feature_name': value}

Estos Dataset de objetos son iterable. Veamos un lote de características:

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)>)])

Tenga en cuenta que afines características se agrupan juntos, o por lotes. Los campos de cada fila de ejemplo se añaden a la matriz de características correspondiente. Cambiar el batch_size para establecer el número de ejemplos almacenados en estas matrices de características.

Puede comenzar a ver algunos clústeres trazando algunas características del 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 la etapa de construcción del modelo, crear una función para volver a empaquetar las características diccionario en una única matriz con forma: (batch_size, num_features) .

Esta función utiliza la tf.stack método que toma valores de una lista de los tensores y crea un tensor combinado a la dimensión 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

A continuación, utilice el tf.data.Dataset#map método para empacar las features de cada uno (features,label) par en la formación de datos:

train_dataset = train_dataset.map(pack_features_vector)

El elemento de características del Dataset son ahora matrices con forma (batch_size, num_features) . Veamos los primeros ejemplos:

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)

Seleccione el tipo de modelo

¿Por qué modelar?

Un modelo es una relación entre las características y la etiqueta. Para el problema de clasificación de Iris, el modelo define la relación entre las medidas del sépalo y pétalo y la especie de Iris predicha. Algunos modelos simples se pueden describir con unas pocas líneas de álgebra, pero los modelos complejos de aprendizaje automático tienen una gran cantidad de parámetros que son difíciles de resumir.

¿Podría determinar la relación entre las cuatro características y las especies Iris sin necesidad de utilizar la máquina de aprendizaje? Es decir, ¿podría utilizar técnicas de programación tradicionales (por ejemplo, muchas declaraciones condicionales) para crear un modelo? Quizás, si analizó el conjunto de datos el tiempo suficiente para determinar las relaciones entre las medidas de pétalos y sépalos para una especie en particular. Y esto se vuelve difícil, tal vez imposible, en conjuntos de datos más complicados. Un enfoque de aprendizaje automático buena determina el modelo para usted. Si introduce suficientes ejemplos representativos en el tipo de modelo de aprendizaje automático correcto, el programa descubrirá las relaciones por usted.

Seleccione el modelo

Necesitamos seleccionar el tipo de modelo a entrenar. Hay muchos tipos de modelos y elegir uno bueno requiere experiencia. Este tutorial utiliza una red neuronal para resolver el problema de clasificación de Iris. Las redes neuronales pueden encontrar relaciones complejas entre las características y la etiqueta. Es un gráfico altamente estructurado, organizada en una o más capas ocultas . Cada capa oculta se compone de uno o más neuronas . Hay varias categorías de redes neuronales y este programa utiliza un denso, o red neuronal plenamente conectado : las neuronas de una capa reciben conexiones de entrada de cada neurona en la capa anterior. Por ejemplo, la Figura 2 ilustra una red neuronal densa que consta de una capa de entrada, dos capas ocultas y una capa de salida:

Un diagrama de la arquitectura de la red: entradas, 2 capas ocultas y salidas
Figura 2. Una red neuronal con las características, las capas ocultas, y predicciones.

Cuando el modelo de la Figura 2 se entrena y se alimenta con un ejemplo sin etiquetar, arroja tres predicciones: la probabilidad de que esta flor sea la especie de Iris dada. Esta predicción se llama inferencia . Para este ejemplo, la suma de las predicciones de salida es 1.0. En la Figura 2, esta predicción se descompone como: 0.02 para Iris setosa, 0.95 para Iris versicolor, y 0.03 para Iris virginica. Esto significa que el modelo predice-con 95% de probabilidad-que una flor de ejemplo no marcado es una versicolor Iris.

Crea un modelo usando Keras

El TensorFlow tf.keras API es la manera preferida para crear modelos y capas. Esto facilita la creación de modelos y la experimentación, mientras que Keras maneja la complejidad de conectar todo.

El tf.keras.Sequential modelo es una pila lineal de capas. Su constructor toma una lista de instancias de capa, en este caso, dos tf.keras.layers.Dense capas con 10 nodos cada uno, y una capa de salida con 3 nodos que representan nuestras predicciones de la etiqueta. La primera capa es input_shape parámetro corresponde al número de características del conjunto de datos, y se requiere:

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)
])

La función de activación determina la forma de salida de cada nodo en la capa. Estas no linealidades son importantes; sin ellas, el modelo sería equivalente a una sola capa. Hay muchos tf.keras.activations , pero RELU es común para las capas ocultas.

El número ideal de capas y neuronas ocultas depende del problema y del conjunto de datos. Como muchos aspectos del aprendizaje automático, elegir la mejor forma de la red neuronal requiere una mezcla de conocimiento y experimentación. Como regla general, aumentar la cantidad de capas y neuronas ocultas generalmente crea un modelo más poderoso, que requiere más datos para entrenar de manera efectiva.

Usando el modelo

Echemos un vistazo rápido a lo que hace este modelo con un lote de características:

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)>

Aquí, cada ejemplo devuelve un logit para cada clase.

Para convertir estos logits a una probabilidad para cada clase, utilice el softmax función:

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 el tf.argmax través de las clases nos da el índice de clase predicho. Pero, el modelo aún no se ha entrenado, por lo que estas no son buenas predicciones:

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]

Entrena el modelo

La formación es la etapa de aprendizaje automático cuando el modelo está optimizado gradualmente, o el modelo aprende el conjunto de datos. El objetivo es aprender lo suficiente sobre la estructura del conjunto de datos de entrenamiento para hacer predicciones sobre datos invisibles. Si se aprende mucho acerca de la formación de datos, entonces las predicciones sólo funcionan para los datos que ha visto y no ser generalizables. Este problema se llama sobreajuste -Es como memorizar las respuestas en lugar de comprender la forma de resolver un problema.

El problema de clasificación Iris es un ejemplo de la máquina de aprendizaje supervisado : el modelo se entrena a partir de ejemplos que contienen etiquetas. En la máquina de aprendizaje no supervisado , los ejemplos no contienen etiquetas. En cambio, el modelo normalmente encuentra patrones entre las características.

Definir la función de pérdida y gradiente

Ambas etapas de formación y evaluación necesitan para calcular el modelo de pérdida . Esto mide qué tan fuera de las predicciones de un modelo de la etiqueta deseada, en otras palabras, qué tan mal se está desempeñando el modelo. Queremos minimizar u optimizar este valor.

Nuestro modelo calculará su pérdida utilizando el tf.keras.losses.SparseCategoricalCrossentropy función que toma predicciones de probabilidad de clase del modelo y la etiqueta deseada, y devuelve la pérdida promedio a través de los ejemplos.

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

Usar la tf.GradientTape contexto para calcular los gradientes utilizados para optimizar su 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)

Crea un optimizador

Un optimizador aplica los gradientes calculados para las variables del modelo para reducir al mínimo la loss función. Puede pensar en la función de pérdida como una superficie curva (ver Figura 3) y queremos encontrar su punto más bajo caminando. Los gradientes apuntan en la dirección del ascenso más empinado, por lo que viajaremos en la dirección opuesta y bajaremos la colina. Al calcular de forma iterativa la pérdida y el gradiente de cada lote, ajustaremos el modelo durante el entrenamiento. Gradualmente, el modelo encontrará la mejor combinación de pesos y sesgo para minimizar la pérdida. Y cuanto menor sea la pérdida, mejores serán las predicciones del modelo.

Algoritmos de optimización visualizados en el tiempo en el espacio 3D.
Figura 3. algoritmos de optimización visualizados a través del tiempo en el espacio 3D.
(Fuente: Stanford clase CS231n , MIT License, Crédito de la imagen: Alec Radford )

TensorFlow tiene muchos algoritmos de optimización disponibles para entrenamiento. Este modelo usa la tf.keras.optimizers.SGD que implementa el descenso de gradiente estocástico (SGD) algoritmo. El learning_rate establece el tamaño de paso a tomar para cada iteración de la colina. Se trata de un hiperparámetro que comúnmente se le ajusta para lograr mejores resultados.

Configuremos el optimizador:

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

Usaremos esto para calcular un solo paso de optimización:

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

Bucle de entrenamiento

Con todas las piezas en su lugar, ¡el modelo está listo para entrenar! Un ciclo de entrenamiento alimenta los ejemplos de conjuntos de datos en el modelo para ayudarlo a realizar mejores predicciones. El siguiente bloque de código configura estos pasos de entrenamiento:

  1. Iterar cada época. Una época es una pasada a través del conjunto de datos.
  2. Dentro de una época, iterar sobre cada ejemplo en la formación Dataset agarrando sus características ( x ) y la etiqueta ( y ).
  3. Utilizando las características del ejemplo, haga una predicción y compárela con la etiqueta. Mida la inexactitud de la predicción y utilícela para calcular la pérdida y los gradientes del modelo.
  4. Utilizar un optimizer para actualizar las variables del modelo.
  5. Mantenga un registro de algunas estadísticas para su visualización.
  6. Repita para cada época.

El num_epochs variable es el número de veces del ciclo sobre la colección de datos. De manera contraria a la intuición, entrenar un modelo por más tiempo no garantiza un modelo mejor. num_epochs es un hiperparámetro que se puede sintonizar. Elegir el número correcto generalmente requiere experiencia y experimentación:

## 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%

Visualice la función de pérdida a lo largo del tiempo.

Si bien es útil imprimir progreso en el entrenamiento del modelo, a menudo es más útil para ver este progreso. TensorBoard es una herramienta de visualización agradable que se empaqueta con TensorFlow, pero podemos crear gráficos básicos utilizando el matplotlib módulo.

La interpretación de estos gráficos toma un poco de experiencia, pero que realmente quieren ver la pérdida de bajar y subir la exactitud:

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

Evaluar la efectividad del modelo

Ahora que el modelo está entrenado, podemos obtener algunas estadísticas sobre su rendimiento.

Medios de determinación de la eficacia del modelo hace predicciones evaluar. Para determinar la efectividad del modelo en la clasificación de Iris, pase algunas medidas de sépalos y pétalos al modelo y pídale al modelo que prediga qué especies de Iris representan. Luego compare las predicciones del modelo con la etiqueta real. Por ejemplo, un modelo que recogió la especie correcta en la mitad de los ejemplos de entrada tiene una precisión de 0.5 . La Figura 4 muestra un modelo ligeramente más efectivo, obteniendo 4 de 5 predicciones correctas con una precisión del 80%:

Funciones de ejemplo Etiqueta Predicción del 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. Un Iris clasificador que es 80% de precisión.

Configurar el conjunto de datos de prueba

Evaluar el modelo es similar a entrenarlo. La mayor diferencia es los ejemplos provienen de una separada de prueba en lugar del conjunto de entrenamiento. Para evaluar de manera justa la efectividad de un modelo, los ejemplos usados ​​para evaluar un modelo deben ser diferentes de los ejemplos usados ​​para entrenar el modelo.

La configuración de la prueba Dataset es similar a la configuración para la formación Dataset . Descargue el archivo de texto CSV y analice esos valores, luego mezcle un poco:

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)

Evaluar el modelo en el conjunto de datos de prueba

A diferencia de la etapa de entrenamiento, el modelo sólo se evalúa una sola época de los datos de prueba. En la siguiente celda de código, iteramos sobre cada ejemplo en el conjunto de prueba y comparamos la predicción del modelo con la etiqueta real. Esto se usa para medir la precisión del modelo en todo el conjunto de prueba:

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 en el último lote, por ejemplo, el modelo suele ser correcto:

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)>

Usa el modelo entrenado para hacer predicciones

Hemos entrenado un modelo y "probado" que es bueno, pero no perfecto, para clasificar las especies de Iris. Ahora vamos a utilizar el modelo entrenado para hacer algunas predicciones sobre ejemplos no etiquetados ; es decir, en ejemplos que contienen características pero no una etiqueta.

En la vida real, los ejemplos sin etiquetas podrían provenir de muchas fuentes diferentes, incluidas aplicaciones, archivos CSV y fuentes de datos. Por ahora, proporcionaremos manualmente tres ejemplos sin etiqueta para predecir sus etiquetas. Recuerde, los números de etiqueta se asignan a una representación con nombre como:

  • 0 : Iris setosa
  • 1 : Iris versicolor
  • 2 : Iris 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%)