advanced.ipynb

Kernel: Python 3

Copyright 2019 The TensorFlow Authors.

#@title Con licencia de Apache License, versión 2.0 (la "Licencia");
# no puede usar este archivo excepto de conformidad con la Licencia.
# Puede obtener una copia de la Licencia en
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# A menos que lo exija la ley aplicable o se acuerde por escrito, el software
# distribuido bajo la Licencia se distribuye "TAL CUAL",
# SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sean expresas o implícitas.
# Consulte la Licencia para conocer el idioma específico que rige los permisos y
# limitaciones bajo la Licencia.

TensorFlow 2: inicio rápido para expertos

Ver en TensorFlow.org

Ejecutar en Google Colab

Ver codigo en GitHub

Descargar bloc de notas

Este es un notebook Google Colaboratory. Los programas de Python se ejecutan directamente en el navegador —una excelente manera de aprender y utilizar TensorFlow. Para poder seguir este tutorial, ejecute este notebook en Google Colab presionando el botón en la parte superior de esta pagina.

1. En Colab, conéctese al tiempo de ejecución de Python: en la parte superior derecha de la barra de menús, seleccione CONNECT.

2. Ejecute todas las celdas de código de notebook: seleccione Runtime > Run all (Tiempo de ejecución > Ejecutar todo).

Descargue e instale TensorFlow 2. Importe TensorFlow a su programa:

Nota: actualice pip para instalar el paquete de TensorFlow 2. Para más detalles, consulte la guía de instalación.

Importe TensorFlow al programa:

import tensorflow as tf
print("TensorFlow version:", tf.__version__)

from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model

Cargue y prepare el conjunto de datos MNIST.

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

# Add a channels dimension
x_train = x_train[..., tf.newaxis].astype("float32")
x_test = x_test[..., tf.newaxis].astype("float32")

Use tf.data para procesar por lotes (batch) y aleatorizar (shuffle) el conjunto de datos:

train_ds = tf.data.Dataset.from_tensor_slices(
    (x_train, y_train)).shuffle(10000).batch(32)

test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

Cree el modelo tf.keras con la API para aplicación de subclases de modelos:

class MyModel(Model):
  def __init__(self):
    super().__init__()
    self.conv1 = Conv2D(32, 3, activation='relu')
    self.flatten = Flatten()
    self.d1 = Dense(128, activation='relu')
    self.d2 = Dense(10)

  def call(self, x):
    x = self.conv1(x)
    x = self.flatten(x)
    x = self.d1(x)
    return self.d2(x)

# Create an instance of the model
model = MyModel()

Elija un optimizador y una función de pérdida para el entrenamiento:

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

optimizer = tf.keras.optimizers.Adam()

Seleccione las métricas para medir la pérdida y la exactitud del modelo. Estas métricas acumulan los valores sobre la épocas y después imprimen el resultado general.

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

Use tf.GradientTape para entrenar al modelo:

@tf.function
def train_step(images, labels):
  with tf.GradientTape() as tape:
    # training=True is only needed if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    predictions = model(images, training=True)
    loss = loss_object(labels, predictions)
  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

  train_loss(loss)
  train_accuracy(labels, predictions)

Pruebe el modelo:

@tf.function
def test_step(images, labels):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  predictions = model(images, training=False)
  t_loss = loss_object(labels, predictions)

  test_loss(t_loss)
  test_accuracy(labels, predictions)

EPOCHS = 5

for epoch in range(EPOCHS):
  # Reset the metrics at the start of the next epoch
  train_loss.reset_states()
  train_accuracy.reset_states()
  test_loss.reset_states()
  test_accuracy.reset_states()

  for images, labels in train_ds:
    train_step(images, labels)

  for test_images, test_labels in test_ds:
    test_step(test_images, test_labels)

  print(
    f'Epoch {epoch + 1}, '
    f'Loss: {train_loss.result()}, '
    f'Accuracy: {train_accuracy.result() * 100}, '
    f'Test Loss: {test_loss.result()}, '
    f'Test Accuracy: {test_accuracy.result() * 100}'
  )

El clasificador de imágenes ahora está entrenado para proporcionar ~98% de exactitud en este conjunto de datos. Para más información, lea los tutoriales de TensorFlow.