TF_2_0_Notes_Working_with_data.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "TF 2.0 Notes - Working with data.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/michelucci/TF20-Notes/blob/master/TF_2_0_Notes_Working_with_data.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-hrlsEg8aVyi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from __future__ import absolute_import, division, print_function, unicode_literals\n",
        "\n",
        "try:\n",
        "  # %tensorflow_version only exists in Colab.\n",
        "  %tensorflow_version 2.x\n",
        "except Exception:\n",
        "  pass\n",
        "import tensorflow as tf\n",
        "\n",
        "tf.keras.backend.clear_session()  # For easy reset of notebook state"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I_eAdOjMbLbI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow import keras\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "50Tv4rLDWRu7",
        "colab_type": "text"
      },
      "source": [
        "# Use of ```tf.data.Dataset```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KxQ_GY4YYF9y",
        "colab_type": "text"
      },
      "source": [
        "Reference\n",
        "\n",
        "https://www.tensorflow.org/beta/guide/data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tYMizQYsYLFi",
        "colab_type": "text"
      },
      "source": [
        "The ```tf.data API``` introduces two new abstractions to TensorFlow:\n",
        "\n",
        "- A ```tf.data.Dataset``` represents a sequence of elements, in which each element contains one or more Tensor objects. For example, in an image pipeline, an element might be a single training example, with a pair of tensors representing the image data and a label. There are two distinct ways to create a dataset:\n",
        "\n",
        "  - Creating a __source__ (e.g. ```Dataset.from_tensor_slices()```) constructs a dataset from one or more ```tf.Tensor``` objects.\n",
        "\n",
        "  - Applying a transformation (e.g. ```Dataset.batch()```) constructs a dataset from one or more ```tf.data.Dataset``` objects.\n",
        "\n",
        "- A ```tf.data.Iterator``` provides the main way to extract elements from a dataset. The operation returned by ```Iterator.get_next()``` yields the next element of a Dataset when executed, and typically acts as the interface between input pipeline code and your model. The simplest iterator is a \"one-shot iterator\", which is associated with a particular Dataset and iterates through it once. For more sophisticated uses, the ```Iterator.initializer``` operation enables you to reinitialize and parameterize an iterator with different datasets, so that you can, for example, iterate over training and validation data multiple times in the same program."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sC9vFwM2ZIBl",
        "colab_type": "text"
      },
      "source": [
        "To work with ```Datasets``` you need to follow the steps:\n",
        "\n",
        "1. First define a source. For example from some data you already have with ```tf.data.Dataset.from_tensors()``` or from ```tf.data.Dataset.from_tensor_slices()```\n",
        "\n",
        "2. Now you have a ```Dataset``` object. You can transform it in another ```Dataset``` object by chaining methods on it. For example using ```Dataset.map()``` (to apply a function to each element), or do multielement transformation with ```Dataset.batch()```.\n",
        "\n",
        "3. Then you create an ```iterator``` object that provides access to one element of the Dataset at a time. For example with ```Dataset.make_one_shot_iterator()```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c0uDWOEWaK4P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qjJNN3ceYyZk",
        "colab_type": "code",
        "outputId": "6d93a3e6-cb77-4c1f-e486-605f2930a210",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 218
        }
      },
      "source": [
        "for elem in dataset:\n",
        "  print(elem)\n",
        "  print(elem.numpy())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tf.Tensor(8, shape=(), dtype=int32)\n",
            "8\n",
            "tf.Tensor(3, shape=(), dtype=int32)\n",
            "3\n",
            "tf.Tensor(0, shape=(), dtype=int32)\n",
            "0\n",
            "tf.Tensor(8, shape=(), dtype=int32)\n",
            "8\n",
            "tf.Tensor(2, shape=(), dtype=int32)\n",
            "2\n",
            "tf.Tensor(1, shape=(), dtype=int32)\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHE_-i97W2dK",
        "colab_type": "text"
      },
      "source": [
        "# Creating an iterator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kCccE2j0W86K",
        "colab_type": "code",
        "outputId": "755e7055-47f5-4689-9264-f9c87fa443b9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "it = iter(dataset)\n",
        "\n",
        "print(next(it).numpy())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tuxc3Jk6X85T",
        "colab_type": "text"
      },
      "source": [
        "# Dataset structure"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ynlt45zvZPwc",
        "colab_type": "code",
        "outputId": "6218a56e-f872-411e-d56a-9d821323b50f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "dataset1 = tf.data.Dataset.from_tensor_slices(tf.random.uniform([4, 10]))\n",
        "\n",
        "dataset1.element_spec"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorSpec(shape=(10,), dtype=tf.float32, name=None)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HyLA-nUxZRgM",
        "colab_type": "code",
        "outputId": "3c163985-c34d-4a6b-ce4f-c3f5eba336c3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "dataset2 = tf.data.Dataset.from_tensor_slices(\n",
        "   (tf.random.uniform([4]),\n",
        "    tf.random.uniform([4, 100], maxval=100, dtype=tf.int32)))\n",
        "\n",
        "dataset2.element_spec"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorSpec(shape=(), dtype=tf.float32, name=None),\n",
              " TensorSpec(shape=(100,), dtype=tf.int32, name=None))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p8gAiGFsZT98",
        "colab_type": "code",
        "outputId": "fa478e69-fb86-4450-a387-96a368c0a782",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "dataset3 = tf.data.Dataset.zip((dataset1, dataset2))\n",
        "\n",
        "dataset3.element_spec"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorSpec(shape=(10,), dtype=tf.float32, name=None),\n",
              " (TensorSpec(shape=(), dtype=tf.float32, name=None),\n",
              "  TensorSpec(shape=(100,), dtype=tf.int32, name=None)))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SuAXlr8nZYk8",
        "colab_type": "text"
      },
      "source": [
        "# Other examples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oovwLIy8ZfA0",
        "colab_type": "code",
        "outputId": "14b094a9-f880-4d3f-8a7b-c988cd3178c2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "dataset1 = tf.data.Dataset.from_tensor_slices(\n",
        "    tf.random.uniform([4, 10], minval=1, maxval=10, dtype=tf.int32))\n",
        "\n",
        "dataset1"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<TensorSliceDataset shapes: (10,), types: tf.int32>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8iMbwynqZfic",
        "colab_type": "code",
        "outputId": "1b6131cc-6866-4934-95f6-05ffa756f203",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "for z in dataset1:\n",
        "  print(z.numpy())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[9 9 8 9 2 6 9 8 6 1]\n",
            "[2 7 7 2 2 5 4 2 9 8]\n",
            "[4 8 4 8 9 7 2 2 4 3]\n",
            "[1 3 2 1 2 9 7 4 2 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PO5vUZcSZhPc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dataset2 = tf.data.Dataset.from_tensor_slices(\n",
        "   (tf.random.uniform([4]),\n",
        "    tf.random.uniform([4, 100], maxval=100, dtype=tf.int32)))\n",
        "dataset3 = tf.data.Dataset.zip((dataset1, dataset2))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0YgghysjZmJN",
        "colab_type": "code",
        "outputId": "b524590e-ab81-40ef-a536-88feb3f52880",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "for a, (b,c) in dataset3:\n",
        "  print('shapes: {a.shape}, {b.shape}, {c.shape}'.format(a=a, b=b, c=c))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "shapes: (10,), (), (100,)\n",
            "shapes: (10,), (), (100,)\n",
            "shapes: (10,), (), (100,)\n",
            "shapes: (10,), (), (100,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O9psI0mZZn9s",
        "colab_type": "text"
      },
      "source": [
        "# MNIST with ```tf.Dataset```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nPFVswu-ZxQU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train, test = tf.keras.datasets.fashion_mnist.load_data()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6f3xCtDOZy0k",
        "colab_type": "code",
        "outputId": "4ac300ae-40dd-4d03-e6f2-a52a9cefa9c5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "images, labels = train\n",
        "images = images/255\n",
        "\n",
        "images.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(60000, 28, 28)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcUF-wiMd3q6",
        "colab_type": "code",
        "outputId": "a11dca81-df8a-4ba2-99d0-21f0e8f57f04",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(labels[:10])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[9 0 0 3 0 2 7 2 5 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V3aL8uZ7cJt5",
        "colab_type": "code",
        "outputId": "f35326af-7a95-4245-ecad-675b1126aaf6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "\n",
        "images = images.reshape((60000, 784))\n",
        "print(images.shape)\n",
        "\n",
        "dataset = tf.data.Dataset.from_tensor_slices((images, labels))\n",
        "train_dataset = dataset.shuffle(buffer_size=1024).batch(64)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(60000, 784)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "17BHD2KGbJOn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = keras.models.Sequential()\n",
        "model.add(keras.layers.Dense(10, input_shape = (784,), activation = \"relu\"))\n",
        "model.add(keras.layers.Dense(10,  activation = \"relu\"))\n",
        "model.add(keras.layers.Dense(10, activation = \"softmax\"))\n",
        "\n",
        "model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(), optimizer='adam', metrics=['accuracy'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A7DzRiI_dI7m",
        "colab_type": "code",
        "outputId": "7e1d8bb5-a3ed-4e9e-da70-c41a12295fda",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "train_dataset"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<BatchDataset shapes: ((None, 784), (None,)), types: (tf.float64, tf.uint8)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5RFM0dw-bojh",
        "colab_type": "code",
        "outputId": "49e38412-eb94-4c4a-bdda-43683f876c0a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 202
        }
      },
      "source": [
        "model.fit(train_dataset, epochs = 5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "938/938 [==============================] - 7s 7ms/step - loss: 1.0401 - accuracy: 0.6018\n",
            "Epoch 2/5\n",
            "938/938 [==============================] - 3s 3ms/step - loss: 0.5146 - accuracy: 0.8242\n",
            "Epoch 3/5\n",
            "938/938 [==============================] - 3s 3ms/step - loss: 0.4554 - accuracy: 0.8415\n",
            "Epoch 4/5\n",
            "938/938 [==============================] - 3s 3ms/step - loss: 0.4269 - accuracy: 0.8509\n",
            "Epoch 5/5\n",
            "938/938 [==============================] - 3s 3ms/step - loss: 0.4099 - accuracy: 0.8558\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.callbacks.History at 0x7f5ba71c92b0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_sNeOKb4Z1mk",
        "colab_type": "text"
      },
      "source": [
        "# Python generators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4UT6yv3rZ8_E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def count(stop):\n",
        "  i = 0\n",
        "  while i < stop:\n",
        "    yield i\n",
        "    i += 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JwT73lTaBLc",
        "colab_type": "code",
        "outputId": "5a5ea2b2-8977-47fe-a15c-46170ba82994",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        }
      },
      "source": [
        "for n in count(5):\n",
        "  print(n)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YVV-SVw8aEE0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ds_counter = tf.data.Dataset.from_generator(count, args=[25], output_types=tf.int32, output_shapes = (), )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IhSVmAXVaedU",
        "colab_type": "code",
        "outputId": "8631de82-7f21-4aff-bb31-dc3ccccda204",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        }
      },
      "source": [
        "for count_batch in ds_counter.repeat().batch(10).take(10):\n",
        "  print(count_batch.numpy())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "[10 11 12 13 14 15 16 17 18 19]\n",
            "[20 21 22 23 24  0  1  2  3  4]\n",
            "[ 5  6  7  8  9 10 11 12 13 14]\n",
            "[15 16 17 18 19 20 21 22 23 24]\n",
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "[10 11 12 13 14 15 16 17 18 19]\n",
            "[20 21 22 23 24  0  1  2  3  4]\n",
            "[ 5  6  7  8  9 10 11 12 13 14]\n",
            "[15 16 17 18 19 20 21 22 23 24]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cSOev9YXakgs",
        "colab_type": "text"
      },
      "source": [
        "# Example flower Photos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3iHOG_RJaykN",
        "colab_type": "code",
        "outputId": "7fed70a4-2df5-4f72-c5f9-36248e12f3e4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "flowers = tf.keras.utils.get_file(\n",
        "    'flower_photos',\n",
        "    'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',\n",
        "    untar=True)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz\n",
            "228818944/228813984 [==============================] - 5s 0us/step\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4YD-G296az6N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "img_gen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255, rotation_range=20)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KrgrzXdVa39V",
        "colab_type": "code",
        "outputId": "4fd585e8-45f4-4756-c909-8f6e9232f5f8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "images, labels = next(img_gen.flow_from_directory(flowers))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found 3670 images belonging to 5 classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8cyOEuUFa6jV",
        "colab_type": "code",
        "outputId": "573fe9d9-d0d7-4be0-b5f4-52832c87724a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "print(images.dtype, images.shape)\n",
        "print(labels.dtype, labels.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "float32 (32, 256, 256, 3)\n",
            "float32 (32, 5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbMGIt0ja99V",
        "colab_type": "code",
        "outputId": "c4e7d387-e381-430a-a228-6a84553e8268",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "ds = tf.data.Dataset.from_generator(\n",
        "    img_gen.flow_from_directory, args=[flowers], \n",
        "    output_types=(tf.float32, tf.float32), \n",
        "    output_shapes = ([32,256,256,3],[32,5])\n",
        ")\n",
        "\n",
        "ds"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<DatasetV1Adapter shapes: ((32, 256, 256, 3), (32, 5)), types: (tf.float32, tf.float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5lGpDKZZbAGG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}