image_summaries.ipynb

Kernel: Python 3

Copyright 2019 The TensorFlow Authors.

#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Visualización de datos de imágenes en TensorBoard

Ver en TensorFlow.org

Ejecutar en Google Colab

Ver fuente en GitHub

Descargar el bloc de notas

Descripción general

Utilizando la API de resumen de imágenes de TensorFlow, puede registrar fácilmente tensores e imágenes arbitrarias y visualizarlos en TensorBoard. Esto puede ser extremadamente útil para tomar muestras y examinar sus datos de entrada, o para visualizar las ponderaciones de las capas y los tensores generados. También puede registrar datos de diagnóstico como imágenes que pueden ser útiles en el curso del desarrollo de su modelo.

En este tutorial, aprenderá a utilizar la API de resumen de imágenes para visualizar tensores como imágenes. También aprenderá a tomar una imagen arbitraria, convertirla en un tensor y visualizarla en TensorBoard. Trabajará mediante un ejemplo simple pero real que utiliza Resúmenes de imágenes para ayudarle a comprender el rendimiento de su modelo.

Preparación

try:
  # %tensorflow_version only exists in Colab.
  %tensorflow_version 2.x
except Exception:
  pass

# Load the TensorBoard notebook extension.
%load_ext tensorboard

TensorFlow 2.x selected.

from datetime import datetime
import io
import itertools
from packaging import version

import tensorflow as tf
from tensorflow import keras

import matplotlib.pyplot as plt
import numpy as np
import sklearn.metrics

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."

TensorFlow version:  2.2

Descargar el conjunto de datos Fashion-MNIST

Va a construir una red neuronal sencilla para clasificar las imágenes del conjunto de datos Fashion-MNIST. Este conjunto de datos contiene 70,000 imágenes en escala de grises de 28x28 sobre productos de moda pertenecientes a 10 categorías, con 7,000 imágenes por categoría.

Primero, descargue los datos:

# Download the data. The data is already divided into train and test.
# The labels are integers representing classes.
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = \
    fashion_mnist.load_data()

# Names of the integer classes, i.e., 0 -> T-short/top, 1 -> Trouser, etc.
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 
    'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

Visualizar una sola imagen

Para comprender cómo funciona la API de resumen de imágenes, ahora va a registrar simplemente la primera imagen de entrenamiento de su conjunto de entrenamiento en TensorBoard.

Antes de hacerlo, examine la forma que adoptan sus datos de entrenamiento:

print("Shape: ", train_images[0].shape)
print("Label: ", train_labels[0], "->", class_names[train_labels[0]])

Shape:  (28, 28)
Label:  9 -> Ankle boot

Observe que la forma de cada imagen del conjunto de datos es un tensor de rango 2 de forma (28, 28), que representa la altura y el ancho.

Sin embargo, tf.summary.image() espera un tensor de rango 4 que contenga (batch_size, height, width, channels). Por lo tanto, es necesario remodelar los tensores.

Está registrando sólo una imagen, así que batch_size es 1. Las imágenes se muestran en escala de grises, lo que significa que channels es 1.

# Reshape the image for the Summary API.
img = np.reshape(train_images[0], (-1, 28, 28, 1))

Ahora está listo para registrar esta imagen y visualizarla en TensorBoard.

# Clear out any prior log data.
!rm -rf logs

# Sets up a timestamped log directory.
logdir = "logs/train_data/" + datetime.now().strftime("%Y%m%d-%H%M%S")
# Creates a file writer for the log directory.
file_writer = tf.summary.create_file_writer(logdir)

# Using the file writer, log the reshaped image.
with file_writer.as_default():
  tf.summary.image("Training data", img, step=0)

Ahora, utilice TensorBoard para examinar la imagen. Espere unos segundos a que la interfaz de usuario gire.

%tensorboard --logdir logs/train_data

El panel "Series temporales" muestra la imagen que acaba de registrar. Es una "bota tobillera".

La imagen se escala a un tamaño predeterminado para facilitar su visualización. Si desea ver la imagen original sin escalar, marque "Mostrar tamaño real de la imagen" en la parte inferior del panel "Configuración" situado a la derecha.

Pruebe con los controles deslizantes de brillo y contraste para ver cómo afectan a los pixeles de la imagen.

Visualización de múltiples imágenes

Registrar un tensor está muy bien, pero ¿y si quisiera registrar múltiples ejemplos de entrenamiento?

Simplemente especifique el número de imágenes que desea registrar al pasar los datos a tf.summary.image().

with file_writer.as_default():
  # Don't forget to reshape.
  images = np.reshape(train_images[0:25], (-1, 28, 28, 1))
  tf.summary.image("25 training data examples", images, max_outputs=25, step=0)

%tensorboard --logdir logs/train_data

Registro de datos de imágenes arbitrarias

¿Y si desea visualizar una imagen que no es un tensor, como una imagen generada por matplotlib?

Se necesita algo de código fuente para convertir el gráfico en un tensor, pero después de esto, estará listo.

En el siguiente código, registrará las primeras 25 imágenes como una agradable cuadrícula utilizando la función subplot() de matplotlib. A continuación, verá la cuadrícula en TensorBoard:

# Clear out prior logging data.
!rm -rf logs/plots

logdir = "logs/plots/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir)

def plot_to_image(figure):
  """Converts the matplotlib plot specified by 'figure' to a PNG image and
  returns it. The supplied figure is closed and inaccessible after this call."""
  # Save the plot to a PNG in memory.
  buf = io.BytesIO()
  plt.savefig(buf, format='png')
  # Closing the figure prevents it from being displayed directly inside
  # the notebook.
  plt.close(figure)
  buf.seek(0)
  # Convert PNG buffer to TF image
  image = tf.image.decode_png(buf.getvalue(), channels=4)
  # Add the batch dimension
  image = tf.expand_dims(image, 0)
  return image

def image_grid():
  """Return a 5x5 grid of the MNIST images as a matplotlib figure."""
  # Create a figure to contain the plot.
  figure = plt.figure(figsize=(10,10))
  for i in range(25):
    # Start next subplot.
    plt.subplot(5, 5, i + 1, title=class_names[train_labels[i]])
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
  
  return figure

# Prepare the plot
figure = image_grid()
# Convert to image and log
with file_writer.as_default():
  tf.summary.image("Training data", plot_to_image(figure), step=0)

%tensorboard --logdir logs/plots

Construir un clasificador de imágenes

Ahora ponga todo esto junto con un ejemplo real. Después de todo, ¡usted está aquí para hacer aprendizaje automático y no para dibujar imágenes bonitas!

Va a utilizar resúmenes de imágenes para comprender lo bien que funciona su modelo mientras entrena un clasificador sencillo para el conjunto de datos Moda-MNIST.

En primer lugar, cree un modelo muy simple y compílelo, establezca el optimizador y la función de pérdida. El paso de la compilación también especifica que desea registrar la precisión del clasificador a lo largo del proceso.

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam', 
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

Al entrenar un clasificador, es útil ver la matriz de confusión. La matriz de confusión le da un conocimiento detallado del rendimiento de su clasificador en los datos de prueba.

Definir una función que calcula la matriz de confusión. Utilizará una conveniente función Scikit-learn para hacerlo, y luego la representará gráficamente utilizando matplotlib.

def plot_confusion_matrix(cm, class_names):
  """
  Returns a matplotlib figure containing the plotted confusion matrix.

  Args:
    cm (array, shape = [n, n]): a confusion matrix of integer classes
    class_names (array, shape = [n]): String names of the integer classes
  """
  figure = plt.figure(figsize=(8, 8))
  plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
  plt.title("Confusion matrix")
  plt.colorbar()
  tick_marks = np.arange(len(class_names))
  plt.xticks(tick_marks, class_names, rotation=45)
  plt.yticks(tick_marks, class_names)

  # Compute the labels from the normalized confusion matrix.
  labels = np.around(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], decimals=2)

  # Use white text if squares are dark; otherwise black.
  threshold = cm.max() / 2.
  for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
    color = "white" if cm[i, j] > threshold else "black"
    plt.text(j, i, labels[i, j], horizontalalignment="center", color=color)

  plt.tight_layout()
  plt.ylabel('True label')
  plt.xlabel('Predicted label')
  return figure

Ahora está listo para entrenar al clasificador y registrar regularmente la matriz de confusión a lo largo del proceso.

Esto es lo que deberá hacer:

1. Cree la retrollamada Keras TensorBoard para registrar las métricas básicas

2. Crear un Keras LambdaCallback para registrar la matriz de confusión al final de cada época.

3. Entrene el modelo utilizando Model.fit(), asegurándose de pasar ambas retrollamadas

Conforme avanza el entrenamiento, desplácese hacia abajo para ver cómo se pone en marcha el TensorBoard.

# Clear out prior logging data.
!rm -rf logs/image

logdir = "logs/image/" + datetime.now().strftime("%Y%m%d-%H%M%S")
# Define the basic TensorBoard callback.
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)
file_writer_cm = tf.summary.create_file_writer(logdir + '/cm')

def log_confusion_matrix(epoch, logs):
  # Use the model to predict the values from the validation dataset.
  test_pred_raw = model.predict(test_images)
  test_pred = np.argmax(test_pred_raw, axis=1)

  # Calculate the confusion matrix.
  cm = sklearn.metrics.confusion_matrix(test_labels, test_pred)
  # Log the confusion matrix as an image summary.
  figure = plot_confusion_matrix(cm, class_names=class_names)
  cm_image = plot_to_image(figure)

  # Log the confusion matrix as an image summary.
  with file_writer_cm.as_default():
    tf.summary.image("epoch_confusion_matrix", cm_image, step=epoch)

# Define the per-epoch callback.
cm_callback = keras.callbacks.LambdaCallback(on_epoch_end=log_confusion_matrix)

# Start TensorBoard.
%tensorboard --logdir logs/image

# Train the classifier.
model.fit(
    train_images,
    train_labels,
    epochs=5,
    verbose=0, # Suppress chatty output
    callbacks=[tensorboard_callback, cm_callback],
    validation_data=(test_images, test_labels),
)

Observe que la precisión aumenta tanto en los conjuntos de entrenamiento como en los de validación. Es una buena señal. Pero, ¿cómo se comporta el modelo en subconjuntos específicos de los datos?

Desplácese por el panel "Series temporales" para visualizar las matrices de confusión registradas. Marque "Mostrar tamaño real de la imagen" en la parte inferior del panel "Configuración" para ver la matriz de confusión a tamaño completo.

De forma predeterminada, el panel muestra el resumen de imágenes del último paso o época registrado. Utilice el control deslizante para ver matrices de confusión anteriores. Observe cómo la matriz cambia significativamente conforme avanza el entrenamiento, con cuadrados más oscuros que se unen a lo largo de la diagonal, y el resto de la matriz tendiendo hacia el 0 y el blanco. ¡Esto significa que su clasificador está mejorando a medida que avanza el entrenamiento! ¡Gran trabajo!

La matriz de confusión muestra que este sencillo modelo tiene algunos problemas. A pesar de los grandes progresos, las camisas, las camisetas y los jerseys se confunden entre sí. El modelo necesita más trabajo.

Si le interesa, intente mejorar este modelo con una red convolucional (CNN).