beginner.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.

TensorFlow 2: inicio rápido para principiantes

Ver en TensorFlow.org

Ejecutar en Google Colab

Ver fuente en GitHub

Descargar notebook

En esta breve introducción se usa Keras para:

1. Cargar un conjunto de datos predeterminado.

2. Crear un modelo de aprendizaje automático de red neural que clasifique las imágenes.

3. Entrenar la red neural.

4. Evaluar la exactitud del modelo.

Este tutorial es un notebook de Google Colaboratory. Los programas de Python se ejecutan directamente en tu navegador —una gran manera de aprender y utilizar TensorFlow. Para poder seguir este tutorial, presione el botón que se encuentra en la parte superior de esta página y ejecute este notebook en Google Colab.

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. Para ejecutar todo el código en el notebook, seleccione Runtime > Run all. Para ejecutar las celdas de a una, coloque el mouse sobre cada celda y seleccione el ícono para ejecutar la celda.

Preparación de TensorFlow

Para empezar, importe TensorFlow a su programa:

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

Si está siguiendo los pasos en su propio entorno de desarrollo y no en Colab, consulte esta guía de instalación para configurar TensorFlow para el desarrollo.

Nota: controle haber actualizado a la última versión de pip para instalar el paquete de TensorFlow 2 en caso de que use su propio entorno de desarrollo. Para más detalles, consulte la guía de instalación.

Carga de un conjunto de datos

Cargue y prepare conjunto de datos MNIST. Los valores de los pixeles de las imágenes van de 0 a 255. Escale esos valores a un rango de 0 a 1 dividiendo los valores por 255.0. De este modo, también se convierten los datos de muestra de los enteros a números de punto flotante:

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

Creación de un modelo de aprendizaje automático

Cree un modelo tf.keras.Sequential:

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

Sequential es útil para apilar capas donde cada una tiene un tensor de entrada y uno de salida. Las capas son funciones con una estructura matemática desconocida que se puede reutilizar y que tiene variables entrenables. La mayoría de los modelos TensorFlow están compuestos por capas. Este modelo usa las capas Flatten, Dense y Dropout.

Para cada ejemplo, el modelo devuelve un vector de logits o puntajes de log-odds (registro de probabilidades) por cada clase.

predictions = model(x_train[:1]).numpy()
predictions

La función tf.nn.softmax convierte estas funciones logits en probabilidades para cada clase:

tf.nn.softmax(predictions).numpy()

Nota: es posible aplicar la función tf.nn.softmax en la función de activación para la última capa de la red. Si bien esto puede hacer que la salida del modelo se interprete más directamente, este enfoque no se recomienda ya que es imposible proporcionar un cálculo de pérdida numéricamente estable y exacto para todos los modelos con salida softmax.

Defina la función de pérdida para el entrenamiento con losses.SparseCategoricalCrossentropy:

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

La función de pérdida toma un vector de valores verdaderos de base y un vector de logits y devuelve una pérdida escalar para cada ejemplo. Esta pérdida es igual a la probabilidad de registro negativa de la clase verdadera: La pérdida es cero si el modelo está seguro de la clase correcta.

El modelo sin entrenar arroja probabilidades cercanas al lo aleatorio (1/10 para cada clase), entonces, la pérdida inicial debería estar cerca de -tf.math.log(1/10) ~= 2.3.

loss_fn(y_train[:1], predictions).numpy()

Antes de empezar el entrenamiento, configure y compile el modelo con Keras Model.compile. Configure la clase del optimizador como adam, establezca loss para la función loss_fn que definió antes y especifique una métrica a evaluar para el modelo, mediante la determinación del parámetro metrics para accuracy.

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

Entrenamiento y evaluación del modelo

Use el método Model.fit para ajustar los parámetros del modelo y minimizar la pérdida:

model.fit(x_train, y_train, epochs=5)

El método Model.evaluate controla el desempeño del modelo, por lo general con un conjunto de evaluación o un conjunto de prueba.

model.evaluate(x_test,  y_test, verbose=2)

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.

Si desea que su modelo devuelva una probabilidad, puede empaquetar el modelo entrenado y adjuntarle el softmax:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])

probability_model(x_test[:5])

Conclusión

¡Felicitaciones! Ha entrenado un modelo de entrenamiento automático con un conjunto de datos predeterminado usando la API Keras.

Para acceder a más ejemplos sobre el uso de Keras, consulte los tutoriales. Para más información sobre cómo crear modelos con Keras, lea las guías. Si quiere aprender más sobre cómo cargar y preparar los datos, mire los tutoriales sobre carga de datos de imágenes o carga de datos CSV.