site/es-419/guide/checkpoint.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pnn4rDWGqDZL"
      },
      "source": [
        "##### Copyright 2018 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "l534d35Gp68G"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3TI3Q3XBesaS"
      },
      "source": [
        "# Entrenar puntos de verificación"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yw_a0iGucY8z"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td><a target=\"_blank\" href=\"https://www.tensorflow.org/guide/checkpoint\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\">Ver en TensorFlow.org</a></td>\n",
        "  <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/es-419/guide/checkpoint.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\">Ejecutar en Google Colab</a></td>\n",
        "  <td>     <a target=\"_blank\" href=\"https://github.com/tensorflow/docs-l10n/blob/master/site/es-419/guide/checkpoint.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\">Ver código fuente en GitHub</a>\n",
        "</td>\n",
        "  <td>     <a href=\"https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/es-419/guide/checkpoint.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\">Descargar bloc de notas</a>\n",
        "</td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LeDp7dovcbus"
      },
      "source": [
        "La frase \"Guardar un modelo de TensorFlow\" normalmente significa una de dos cosas:\n",
        "\n",
        "1. Puntos de verificación, O\n",
        "2. SavedModel.\n",
        "\n",
        "Los puntos de verificación capturan el valor exacto de todos los parámetros (tf.objetos `tf.Variable`) que usa un modelo. Los puntos de verificación no contienen ninguna descripción del cálculo definido por el modelo y, por lo tanto, solo suelen ser útiles cuando el código fuente que usará los valores de los parámetros guardados está disponible.\n",
        "\n",
        "Por otro lado, el formato SavedModel incluye una descripción serializada del cálculo definido por el modelo además de los valores de los parámetros (punto de verificación). Los modelos en este formato son independientes del código fuente que creó el modelo. Por lo tanto, son adecuados para implementarse a través de TensorFlow Serving, TensorFlow Lite, TensorFlow.js o mediante programas en otros lenguajes de programación (las API de TensorFlow C, C++, Java, Go, Rust, C#, etc.).\n",
        "\n",
        "Esta guía cubre las API para escribir y leer puntos de verificación."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U0nm8k-6xfh2"
      },
      "source": [
        "## Preparación"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VEvpMYAKsC4z"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OEQCseyeC4Ev"
      },
      "outputs": [],
      "source": [
        "class Net(tf.keras.Model):\n",
        "  \"\"\"A simple linear model.\"\"\"\n",
        "\n",
        "  def __init__(self):\n",
        "    super(Net, self).__init__()\n",
        "    self.l1 = tf.keras.layers.Dense(5)\n",
        "\n",
        "  def call(self, x):\n",
        "    return self.l1(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "utqeoDADC5ZR"
      },
      "outputs": [],
      "source": [
        "net = Net()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5vsq3-pffo1I"
      },
      "source": [
        "## Guardar desde las API de entrenamiento `tf.keras`\n",
        "\n",
        "Consulte la [guía de `tf.keras` sobre cómo guardar y restaurar](https://www.tensorflow.org/guide/keras/save_and_serialize).\n",
        "\n",
        "`tf.keras.Model.save_weights` guarda un punto de verificación de TensorFlow. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SuhmrYPEl4D_"
      },
      "outputs": [],
      "source": [
        "net.save_weights('easy_checkpoint')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XseWX5jDg4lQ"
      },
      "source": [
        "## Escribir puntos de verificación\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1jpZPz76ZP3K"
      },
      "source": [
        "El estado persistente de un modelo de TensorFlow se almacena en objetos `tf.Variable`. Estos se pueden construir directamente, pero a menudo se crean a través de una API de alto nivel como `tf.keras.layers` o `tf.keras.Model`.\n",
        "\n",
        "La forma más fácil de gestionar variables es adjuntarlas a objetos de Python y luego hacer referencia a esos objetos.\n",
        "\n",
        "Las subclases de `tf.train.Checkpoint`, `tf.keras.layers.Layer` y `tf.keras.Model` trazan automáticamente las variables asignadas a sus atributos. En el siguiente ejemplo, se construye un modelo lineal simple y luego se escriben puntos de verificación que contienen valores para todas las variables del modelo."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x0vFBr_Im73_"
      },
      "source": [
        "Puede guardar un punto de verificación del modelo fácilmente con `Model.save_weights`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FHTJ1JzxCi8a"
      },
      "source": [
        "### Puntos de verificación manuales"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6cF9fqYOCrEO"
      },
      "source": [
        "#### Preparación"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fNjf9KaLdIRP"
      },
      "source": [
        "Para ayudar a demostrar todas las características de `tf.train.Checkpoint`, defina un conjunto de datos de juguete y un paso de optimización:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tSNyP4IJ9nkU"
      },
      "outputs": [],
      "source": [
        "def toy_dataset():\n",
        "  inputs = tf.range(10.)[:, None]\n",
        "  labels = inputs * 5. + tf.range(5.)[None, :]\n",
        "  return tf.data.Dataset.from_tensor_slices(\n",
        "    dict(x=inputs, y=labels)).repeat().batch(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ICm1cufh_JH8"
      },
      "outputs": [],
      "source": [
        "def train_step(net, example, optimizer):\n",
        "  \"\"\"Trains `net` on `example` using `optimizer`.\"\"\"\n",
        "  with tf.GradientTape() as tape:\n",
        "    output = net(example['x'])\n",
        "    loss = tf.reduce_mean(tf.abs(output - example['y']))\n",
        "  variables = net.trainable_variables\n",
        "  gradients = tape.gradient(loss, variables)\n",
        "  optimizer.apply_gradients(zip(gradients, variables))\n",
        "  return loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vxzGpHRbOVO6"
      },
      "source": [
        "#### Crear los objetos del punto de verificación\n",
        "\n",
        "Use un objeto `tf.train.Checkpoint` para crear un punto de verificación de forma manual, donde los objetos de los que se quiera guardar un punto de verificación se establezcan como atributos en el objeto.\n",
        "\n",
        "Un `tf.train.CheckpointManager` también puede resultar útil para gestionar varios puntos de verificación."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ou5qarOQOWYl"
      },
      "outputs": [],
      "source": [
        "opt = tf.keras.optimizers.Adam(0.1)\n",
        "dataset = toy_dataset()\n",
        "iterator = iter(dataset)\n",
        "ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator)\n",
        "manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ZbYSD4uCy96"
      },
      "source": [
        "#### Entrenar y guardar puntos de verificación del modelo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NP9IySmCeCkn"
      },
      "source": [
        "En el siguiente ciclo de entrenamiento, se crea una instancia del modelo y de un optimizador, luego se reúnen en un objeto `tf.train.Checkpoint`. Se llama al paso de entrenamiento en un bucle en cada lote de datos y se escriben puntos de verificación en el disco de manera periódica."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BbCS5A6K1VSH"
      },
      "outputs": [],
      "source": [
        "def train_and_checkpoint(net, manager):\n",
        "  ckpt.restore(manager.latest_checkpoint)\n",
        "  if manager.latest_checkpoint:\n",
        "    print(\"Restored from {}\".format(manager.latest_checkpoint))\n",
        "  else:\n",
        "    print(\"Initializing from scratch.\")\n",
        "\n",
        "  for _ in range(50):\n",
        "    example = next(iterator)\n",
        "    loss = train_step(net, example, opt)\n",
        "    ckpt.step.assign_add(1)\n",
        "    if int(ckpt.step) % 10 == 0:\n",
        "      save_path = manager.save()\n",
        "      print(\"Saved checkpoint for step {}: {}\".format(int(ckpt.step), save_path))\n",
        "      print(\"loss {:1.2f}\".format(loss.numpy()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ik3IBMTdPW41"
      },
      "outputs": [],
      "source": [
        "train_and_checkpoint(net, manager)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2wzcc1xYN-sH"
      },
      "source": [
        "#### Recuperar y continuar el entrenamiento"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lw1QeyRBgsLE"
      },
      "source": [
        "Después del primer ciclo de entrenamiento, se puede aprobar un modelo y gestor nuevos, pero se puede continuar con el entrenamiento exactamente desde donde se dejó:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UjilkTOV2PBK"
      },
      "outputs": [],
      "source": [
        "opt = tf.keras.optimizers.Adam(0.1)\n",
        "net = Net()\n",
        "dataset = toy_dataset()\n",
        "iterator = iter(dataset)\n",
        "ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator)\n",
        "manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=3)\n",
        "\n",
        "train_and_checkpoint(net, manager)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dxJT9vV-2PnZ"
      },
      "source": [
        "El objeto `tf.train.CheckpointManager` elimina puntos de verificación antiguos. En el ejemplo anterior, está configurado para conservar solo los tres puntos de verificación más recientes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3zmM0a-F5XqC"
      },
      "outputs": [],
      "source": [
        "print(manager.checkpoints)  # List the three remaining checkpoints"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qwlYDyjemY4P"
      },
      "source": [
        "Estas rutas, por ejemplo, `'./tf_ckpts/ckpt-10'`, no son archivos en el disco. En realidad, son prefijos para un archivo `index` y uno o más archivos de datos que contienen los valores de las variables. Estos prefijos se agrupan en un único archivo `checkpoint` (`'./tf_ckpts/checkpoint'`) donde `CheckpointManager` guarda su estado."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t1feej9JntV_"
      },
      "outputs": [],
      "source": [
        "!ls ./tf_ckpts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DR2wQc9x6b3X"
      },
      "source": [
        "<a id=\"loading_mechanics\"></a>\n",
        "\n",
        "## Mecánica de carga\n",
        "\n",
        "TensorFlow une a las variables con los valores de los que se guardaron los puntos de verificación al recorrer un gráfico dirigido con bordes con nombre, comenzando desde el objeto que se está cargando. Los nombres de los bordes normalmente provienen de nombres de atributos en objetos, por ejemplo `\"l1\"` en `self.l1 = tf.keras.layers.Dense(5)`. `tf.train.Checkpoint` usa los nombres de sus argumentos de palabras clave, como en el `\"step\"` en `tf.train.Checkpoint(step=...)`.\n",
        "\n",
        "El gráfico de dependencia del ejemplo anterior se ve así:\n",
        "\n",
        "![Visualización del gráfico de dependencia para el bucle de entrenamiento de ejemplo.](https://tensorflow.org/images/guide/whole_checkpoint.svg)\n",
        "\n",
        "El optimizador es rojo, las variables regulares son azules y las variables de ranura del optimizador son naranja. Los otros nodos (por ejemplo, los que representan `tf.train.Checkpoint`) están en negro.\n",
        "\n",
        "Las variables de ranura son parte del estado del optimizador, pero se crean para una variable específica. Por ejemplo, los bordes `'m'` anteriores corresponden al impulso, que el optimizador Adam rastrea para cada variable. Las variables de ranura solo se guardan en un punto de verificación solo si se guardan la variable y el optimizador, por eso se muestran con bordes discontinuos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpY5IuanUEQ0"
      },
      "source": [
        "Cuando se llama `restore` en un objeto `tf.train.Checkpoint` se ponen en cola las restauraciones solicitadas y se restauran los valores de las variables tan pronto como haya una ruta de unión desde el objeto `Checkpoint`. Por ejemplo, solo se puede cargar el sesgo del modelo que se definió anteriormente al reconstruir una ruta hacia él a través de la red y la capa."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wmX2AuyH7TVt"
      },
      "outputs": [],
      "source": [
        "to_restore = tf.Variable(tf.zeros([5]))\n",
        "print(to_restore.numpy())  # All zeros\n",
        "fake_layer = tf.train.Checkpoint(bias=to_restore)\n",
        "fake_net = tf.train.Checkpoint(l1=fake_layer)\n",
        "new_root = tf.train.Checkpoint(net=fake_net)\n",
        "status = new_root.restore(tf.train.latest_checkpoint('./tf_ckpts/'))\n",
        "print(to_restore.numpy())  # This gets the restored value."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GqEW-_pJDAnE"
      },
      "source": [
        "El gráfico de dependencia para estos objetos nuevos es un subgráfico mucho más pequeño del punto de verificación más grande que se escribió anteriormente. Incluye solo el sesgo y un contador de guardado que `tf.train.Checkpoint` usa para enumerar los puntos de verificación.\n",
        "\n",
        "![Visualización de un subgráfico para la variable de sesgo.](https://tensorflow.org/images/guide/partial_checkpoint.svg)\n",
        "\n",
        "`restore` devuelve un objeto de estado, que tiene aserciones opcionales. Todos los objetos creados en el nuevo `Checkpoint` han sido restauradas, por eso `status.assert_existing_objects_matched` pasa."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "P9TQXl81Dq5r"
      },
      "outputs": [],
      "source": [
        "status.assert_existing_objects_matched()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GoMwf8CFDu9r"
      },
      "source": [
        "Hay muchos objetos en el punto de verificación que no se corresponden, incluido el núcleo de la capa y las variables del optimizador. `status.assert_consumed` solo pasa si el punto de verificación y el programa se corresponden exactamente, y se generaría una excepción en este caso."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KCcmJ-2j9RUP"
      },
      "source": [
        "### Restauraciones diferidas\n",
        "\n",
        "Los objetos `Layer` en TensorFlow pueden diferir la creación de variables hasta su primera llamada, cuando las formas de entrada están disponibles. Por ejemplo, la forma del núcleo de una capa `Dense` depende tanto de las formas de entrada como de la salida de la capa,. Por lo tanto, la forma de salida requerida como argumento del constructor no es información suficiente para crear la variable por sí sola. Dado que al llamar a una `Layer` también se lee el valor de la variable, se debe realizar una restauración entre la creación de la variable y su primer uso.\n",
        "\n",
        "Para admitir este modismo, `tf.train.Checkpoint` pospone las restauraciones que aún no tienen una variable correspondiente."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TXYUCO3v-I72"
      },
      "outputs": [],
      "source": [
        "deferred_restore = tf.Variable(tf.zeros([1, 5]))\n",
        "print(deferred_restore.numpy())  # Not restored; still zeros\n",
        "fake_layer.kernel = deferred_restore\n",
        "print(deferred_restore.numpy())  # Restored"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-DWhJ3glyobN"
      },
      "source": [
        "### Inspeccionar manualmente los puntos de verificación\n",
        "\n",
        "`tf.train.load_checkpoint` devuelve un `CheckpointReader` que brinda acceso de nivel inferior al contenido del punto de verificación. Contiene asignaciones de la clave de cada variable, la forma y el dtype de cada variable en el punto de verificación. La clave de una variable es la ruta de su objeto, como en los gráficos anteriores.\n",
        "\n",
        "Nota: No existe una estructura de nivel más superior que el punto de verificación. Solo conoce las rutas y los valores de las variables y no entiende de `models`, `layers` ni cómo están conectados."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RlRsADTezoBD"
      },
      "outputs": [],
      "source": [
        "reader = tf.train.load_checkpoint('./tf_ckpts/')\n",
        "shape_from_key = reader.get_variable_to_shape_map()\n",
        "dtype_from_key = reader.get_variable_to_dtype_map()\n",
        "\n",
        "sorted(shape_from_key.keys())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AVrdvbNvgq5V"
      },
      "source": [
        "Entonces, si quiere saber el valor de `net.l1.kernel`, se puede obtener con el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lYhX_XWCgl92"
      },
      "outputs": [],
      "source": [
        "key = 'net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE'\n",
        "\n",
        "print(\"Shape:\", shape_from_key[key])\n",
        "print(\"Dtype:\", dtype_from_key[key].name)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Zk92jM5gRDW"
      },
      "source": [
        "También proporciona un método `get_tensor` que le permite inspeccionar el valor de una variable:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cDJO3cgmecvi"
      },
      "outputs": [],
      "source": [
        "reader.get_tensor(key)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5fxk_BnZ4W1b"
      },
      "source": [
        "### Seguimiento de objetos\n",
        "\n",
        "Los puntos de verificación guardan y restauran los valores de los objetos `tf.Variable` al \"hacer el seguimiento\" de cualquier variable u objeto rastreable establecido en uno de sus atributos. Al ejecutar un guardado, las variables se recopilan de forma recursiva de todos los objetos rastreados accesibles.\n",
        "\n",
        "Al igual que con las asignaciones directas de atributos como `self.l1 = tf.keras.layers.Dense(5)`, la asignación de listas y diccionarios a atributos hará el seguimiento de su contenido."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rfaIbDtDHAr_"
      },
      "outputs": [],
      "source": [
        "save = tf.train.Checkpoint()\n",
        "save.listed = [tf.Variable(1.)]\n",
        "save.listed.append(tf.Variable(2.))\n",
        "save.mapped = {'one': save.listed[0]}\n",
        "save.mapped['two'] = save.listed[1]\n",
        "save_path = save.save('./tf_list_example')\n",
        "\n",
        "restore = tf.train.Checkpoint()\n",
        "v2 = tf.Variable(0.)\n",
        "assert 0. == v2.numpy()  # Not restored yet\n",
        "restore.mapped = {'two': v2}\n",
        "restore.restore(save_path)\n",
        "assert 2. == v2.numpy()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UTKvbxHcI3T2"
      },
      "source": [
        "Es posible que observe objetos empaquetadores de listas y diccionarios. Estos empaquetadores son versiones que pueden giardarse como puntos de verificación de las estructuras de datos subyacentes. Al igual que la carga basada en atributos, estos empaquetadores restauran el valor de una variable tan pronto como se agrega al contenedor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s0Uq1Hv5JCmm"
      },
      "outputs": [],
      "source": [
        "restore.listed = []\n",
        "print(restore.listed)  # ListWrapper([])\n",
        "v1 = tf.Variable(0.)\n",
        "restore.listed.append(v1)  # Restores v1, from restore() in the previous cell\n",
        "assert 1. == v1.numpy()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OxCIf2J6JyQ8"
      },
      "source": [
        "Los objetos rastreables incluyen `tf.train.Checkpoint`, `tf.Module` y sus subclases (por ejemplo `keras.layers.Layer` y `keras.Model`) y contenedores de Python reconocidos:\n",
        "\n",
        "- `dict` (y `collections.OrderedDict`)\n",
        "- `list`\n",
        "- `tuple` (y `collections.namedtuple`, `typing.NamedTuple`)\n",
        "\n",
        "Entre los tipos de contenedores que **no se admiten** están:\n",
        "\n",
        "- `collections.defaultdict`\n",
        "- `set`\n",
        "\n",
        "Todos los demás objetos de Python se **ignoran**, entre ellos:\n",
        "\n",
        "- `int`\n",
        "- `string`\n",
        "- `float`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "knyUFMrJg8y4"
      },
      "source": [
        "## Resumen\n",
        "\n",
        "Los objetos de TensorFlow proporcionan un mecanismo automático simple para guardar y restaurar los valores de las variables que usan.\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "checkpoint.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}