2-2-data_performance.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JSJeong-me/AI-Innovation-2024/blob/main/2-2-data_performance.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tce3stUlHN0L"
      },
      "source": [
        "##### Copyright 2019 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "cellView": "form",
        "id": "tuOe1ymfHZPu"
      },
      "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": "qFdPvlXBOdUN"
      },
      "source": [
        "# tf.data API로 성능 향상하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MfBg1C5NB3X0"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td data-parent-segment-id=\"13650222\" data-segment-approved=\"false\">     <a target=\"_blank\" href=\"https://www.tensorflow.org/guide/data_performance\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\">TensorFlow.org에서 보기</a>   </td>\n",
        "  <td data-parent-segment-id=\"13650223\" data-segment-approved=\"false\"><a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/ko/guide/data_performance.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\">Google Colab에서 실행</a></td>\n",
        "  <td data-parent-segment-id=\"13650224\" data-segment-approved=\"false\"><a target=\"_blank\" href=\"https://github.com/tensorflow/docs-l10n/blob/master/site/ko/guide/data_performance.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\">GitHub에서 소스 보기</a></td>\n",
        "  <td data-parent-segment-id=\"13650225\" data-segment-approved=\"false\"><a href=\"https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/ko/guide/data_performance.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\">노트북 다운로드</a></td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xHxb-dlhMIzW"
      },
      "source": [
        "## 개요\n",
        "\n",
        "GPU와 TPU는 하나의 학습 단계를 실행하는데 필요한 시간을 급격하게 줄일 수 있습니다. 최대 성능을 위해서는 현재 단계가 종료되기 전에 다음 스텝의 데이터를 운반하는 효율적인 입력 파이프라인이 필요합니다.`tf.data` API는 유연하고 효율적인 입력 파이프라인을 만드는데 도움이 됩니다. 이 문서는 다양한 모델과 가속기에서 고성능의 텐서플로 입력 파이프라인을 만드는 방법과 `tf.data` API의 특정을 설명합니다.\n",
        "\n",
        "진행하기 전에, `tf.data` API 사용법을 익히려면 \"[텐서플로 입력 파이프라인 빌드하기](./data.ipynb)\" 가이드를 읽으십시오."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UhNtHfuxCGVy"
      },
      "source": [
        "## 참고 자료\n",
        "\n",
        "- [텐서플로 입력 파이프라인 빌드하기](./data.ipynb)\n",
        "- `tf.data.Dataset` API\n",
        "- [TF Profiler로 `tf.data` 성능 분석](./data_performance_analysis.md)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MUXex9ctTuDB"
      },
      "source": [
        "## 설정"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "IqR2PQG4ZaZ0"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "import time"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QthTHCKF-jKD"
      },
      "source": [
        "전반적인 가이드에서는 데이터셋을 반복하고 성능을 측정합니다. 재현 가능한 성능 벤치마크를 만드는 것은 그것에 영향을 미치는 다른 요인들로 인해 어려울 수 있습니다. 그 요인들로는:\n",
        "\n",
        "- 현재 CPU 로드,\n",
        "- 네트워크 트래픽,\n",
        "- 캐시와 같은 복잡한 메커니즘 등이 있습니다.\n",
        "\n",
        "따라서 재현 가능한 벤치마크를 제공하기 위해 인공 예제를 빌드합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3bU5gsSI-jKF"
      },
      "source": [
        "### 데이터셋\n",
        "\n",
        "`tf.data.Dataset`에서 상속하여 `ArtificialDataset`이라 불리는 클래스를 정의합니다. 이 데이터셋은:\n",
        "\n",
        "- `num_samples`(기본값은 3)개의 샘플을 생성하기\n",
        "- 첫 번째 항목이 파일 열기를 시뮬레이션하기 전에 일정 시간 동안 휴면\n",
        "- 파일에서 데이터 읽기를 시뮬레이션하기 위해 각 항목을 생성하기 전에 일정 시간 동안 휴면"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "zUQv4kCd-jKH"
      },
      "outputs": [],
      "source": [
        "class ArtificialDataset(tf.data.Dataset):\n",
        "    def _generator(num_samples):\n",
        "        # Opening the file\n",
        "        time.sleep(0.03)\n",
        "\n",
        "        for sample_idx in range(num_samples):\n",
        "            # Reading data (line, record) from the file\n",
        "            time.sleep(0.015)\n",
        "\n",
        "            yield (sample_idx,)\n",
        "\n",
        "    def __new__(cls, num_samples=3):\n",
        "        return tf.data.Dataset.from_generator(\n",
        "            cls._generator,\n",
        "            output_signature = tf.TensorSpec(shape = (1,), dtype = tf.int64),\n",
        "            args=(num_samples,)\n",
        "        )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O9y1WjNv-jKL"
      },
      "source": [
        "이 데이터셋은 `tf.data.Dataset.range`와 유사하며 각 샘플의 시작과 사이에 일정한 지연시간을 추가합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FGK1Y4jn-jKM"
      },
      "source": [
        "### 훈련 루프\n",
        "\n",
        "데이터셋을 반복하는 데 걸리는 시간을 측정하는 더미 훈련 루프를 작성합니다. 훈련 시간이 시뮬레이션됩니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "MIaM3u00-jKP"
      },
      "outputs": [],
      "source": [
        "def benchmark(dataset, num_epochs=2):\n",
        "    start_time = time.perf_counter()\n",
        "    for epoch_num in range(num_epochs):\n",
        "        for sample in dataset:\n",
        "            # Performing a training step\n",
        "            time.sleep(0.01)\n",
        "    print(\"Execution time:\", time.perf_counter() - start_time)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KK58SuXS-jKT"
      },
      "source": [
        "## 성능 최적화\n",
        "\n",
        "성능을 최적화하는 방법을 보여주기 위해 `ArtificialDataset`의 성능을 향상시킵니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xi8t26y7-jKV"
      },
      "source": [
        "### 추상적 접근\n",
        "\n",
        "트릭 없이 추상적 파이프라인으로 시작하여 데이터셋을 그대로 반복합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "_gP7J1y4-jKY",
        "outputId": "1c0a5dc9-1185-42b1-9c72-f1d4f3e7b0d2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.34466718600000945\n"
          ]
        }
      ],
      "source": [
        "benchmark(ArtificialDataset())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lxeat5dH-jKf"
      },
      "source": [
        "실제로는 다음과 같이 실행 시간이 소비되었습니다:\n",
        "\n",
        "![Naive](https://www.tensorflow.org/guide/images/data_performance/naive.svg)\n",
        "\n",
        "이를 포함한 훈련 스텝을 수행하는 것을 볼 수 있습니다:\n",
        "\n",
        "- 아직 열지 않은 경우 파일 열기,\n",
        "- 파일에서 데이터 항목을 가져오기,\n",
        "- 훈련할 데이터 사용하기.\n",
        "\n",
        "그러나 여기와 같은 추상적 동기 구현에서는 파이프라인이 데이터를 가져 오는 동안 모델이 유휴 상태입니다. 반대로, 모델이 훈련하는 동안 입력 파이프라인이 유휴 상태입니다. 따라서 훈련 스텝 시간은 모두 열기, 읽기 및 훈련 시간의 합계입니다.\n",
        "\n",
        "다음 섹션에서는 이 입력 파이프라인을 구축하여 성능이 뛰어난 텐서플로 입력 파이프라인 설계를 위한 모범 사례를 보여줍니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mfukBGNz-jKh"
      },
      "source": [
        "### 가져오기(Prefetching)\n",
        "\n",
        "Prefetching overlaps the preprocessing and model execution of a training step. While the model is executing training step `s`, the input pipeline is reading the data for step `s+1`. Doing so reduces the step time to the maximum (as opposed to the sum) of the training and the time it takes to extract the data.\n",
        "\n",
        "`tf.data` API는 `tf.data.Dataset.prefetch` 변환을 제공합니다. 이를 이용해 데이터가 생성되는 시간과 데이터가 소비되는 시간을 분리할 수 있습니다. 특히 변환에 백그라운드 스레드와 내부 버퍼를 사용하여 요청된 시간보다 앞서 입력 데이터세트에서 요소를 미리 가져옵니다. 미리 가져올 요소의 수는 단일 학습 단계에서 사용되는 배치 수와 같거나 더 많아야 합니다. 이 값을 수동으로 조정하거나, `tf.data` 런타임이 런타임에 값을 동적으로 조정하도록 `tf.data.AUTOTUNE`로 설정할 수 있습니다.\n",
        "\n",
        "프리페치 변환은 \"생산자\"의 작업과 \"소비자\"의 작업을 겹칠 기회가 있을 때마다 이점을 제공합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "DHpUVqH1-jKi",
        "outputId": "ddcb239f-c596-4431-9248-b3d82fe36ce9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.3963000379999926\n"
          ]
        }
      ],
      "source": [
        "benchmark(\n",
        "    ArtificialDataset()\n",
        "    .prefetch(tf.data.AUTOTUNE)\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h7z_kzo--jKn"
      },
      "source": [
        "![Prefetched](https://www.tensorflow.org/guide/images/data_performance/prefetched.svg)\n",
        "\n",
        "이번에는 훈련 스텝이 샘플 0에 대해 실행되는 동안 입력 파이프라인이 샘플 1에 대한 데이터를 읽고 등등 하는 방식을 볼 수 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "52QMKfaY-jKq"
      },
      "source": [
        "### 데이터 추출 병렬화\n",
        "\n",
        "실제 환경에서는 입력 데이터가 로컬에 맞지 않거나 학습이 분산되어 있고 입력 데이터를 모든 컴퓨터에 복제하는 것은 적절하지 않기 때문에 입력 데이터를 원격으로(이를테면, GCS나 HDFS) 저장할 수 있습니다. 데이터를 로컬에서 읽는 데이터셋 파이프라인은 다음과 같은 로컬과 원격 저장소의 차이 때문에 원격으로 데이터를 읽을 때 입출력에 병목이 발생할 수 있습니다:\n",
        "\n",
        "- **첫 번째 바이트(Time-to-first-byte):** 원격 저장소에서 파일의 첫 번째 바이트를 읽는 것은 로컬 저장소에서 읽어 들이는 것보다 훨씬 오래 걸립니다.\n",
        "- **읽기 처리량(Read throughput):** 원격 저장소는 보통 큰 총 대역폭을 가지지만 하나의 파일을 읽을 때 이 대역폭의 일부만 활용할 수 있습니다.\n",
        "\n",
        "게다가 바이트들이 메모리로 읽혀지면 데이터를 역직렬화 그리고/또는 해독할 필요가 있을 수 있습니다(예를 들면, [protobuf](https://developers.google.com/protocol-buffers/)). 이 작업은 추가적인 계산이 필요합니다. 이 오버헤드는 데이터가 로컬 또는 원격으로 저장되는지와는 관계없이 존재하지만 데이터가 효과적으로 프리페치되지 않으면 원격의 경우에 나빠질 수 있습니다.\n",
        "\n",
        "다양한 데이터 추출 오버헤드의 영향을 줄이기 위해 `tf.data.Dataset.interleave` 변환은 (데이터 파일 판독기와 같은)다른 데이터셋의 내용을 인터리빙(interleaving)하여 데이터 추출 단계를 병렬화하는데 사용할 수 있습니다. 중첩할 데이터셋은 `cycle_length` 매개변수에 의해 지정될 수 있는 반면, 병렬처리 수준은 `num_parallel_calls` 매개변수에 의해 지정될 수 있습니다. `prefetch`와 `map` 변환과 비슷하게 `interleave` 변환은 `tf.data.experimental.AUTOTUNE`을 지원합니다. 이것은 어떤 수준의 병렬처리가 tf.data 런타임에 사용되는지에 대해 결정합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gs8O8Vbu-jKu"
      },
      "source": [
        "#### 순차적 인터리브\n",
        "\n",
        "`tf.data.Dataset.interleave` 변환의 기본 인수는 두 개의 데이터셋에서 단일 샘플을 순차적으로 인터리브합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "fDH12GiK-jKw",
        "outputId": "c7dca916-1a76-4fac-f39c-4d335830898a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.5964568090000029\n"
          ]
        }
      ],
      "source": [
        "benchmark(\n",
        "    tf.data.Dataset.range(2)\n",
        "    .interleave(lambda _: ArtificialDataset())\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "78CsSOnf-jK0"
      },
      "source": [
        "![순차적 인터리브](https://www.tensorflow.org/guide/images/data_performance/sequential_interleave.svg)\n",
        "\n",
        "이 그림을 사용하면 `interleave` 변환의 결과를 나타낼 수 있으며 사용가능한 두 데이터셋에서 샘플을 가져오는 것이 가능합니다. 그러나 여기에는 성능 향상이 포함되지 않습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j3cqqmYl-jK2"
      },
      "source": [
        "#### 병렬 인터리브\n",
        "\n",
        "이제 `interleave` 변환의 `num_parallel_calls` 인수를 사용합니다. 이는 여러 병렬 데이터셋을 불러오고, 파일을 여는 데 기다리는 시간을 단축할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "a3FQcTPY-jK4",
        "outputId": "bee62ee5-4f23-4a12-a896-5f0c80ff9afe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.8024311100000006\n"
          ]
        }
      ],
      "source": [
        "benchmark(\n",
        "    tf.data.Dataset.range(2)\n",
        "    .interleave(\n",
        "        lambda _: ArtificialDataset(),\n",
        "        num_parallel_calls=tf.data.AUTOTUNE\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RxRLPB6C-jLA"
      },
      "source": [
        "![병렬 인터리브](https://www.tensorflow.org/guide/images/data_performance/parallel_interleave.svg)\n",
        "\n",
        "이번에는 읽은 두 데이터셋이 병렬화되어 전역 데이터 처리 시간이 줄어듭니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ZCLFWyv-jLB"
      },
      "source": [
        "### 데이터 변환 병렬화\n",
        "\n",
        "데이터를 준비할 때 입력 요소를 사전 처리해야 할 수 있습니다. 이를 위해 `tf.data` API는 입력 데이터세트의 각 요소에 사용자 정의 함수를 적용하는 `tf.data.Dataset.map` 변환을 제공합니다. 입력 요소는 서로 독립적이므로 전처리를 여러 CPU 코어에 걸쳐 병렬화할 수 있습니다. 이를 가능하게 하기 위해 `prefetch` 및 `interleave` 변환과 마찬가지로 `map` 변환은 병렬 처리 수준을 지정하는 `num_parallel_calls` 인수를 제공합니다.\n",
        "\n",
        "`num_parallel_calls` 인수에 가장 적합한 값을 선택하는 것은 하드웨어, 훈련 데이터의 특성(크기 및 형상 등), 맵 함수 비용, CPU에서 동시에 발생하는 기타 처리 등의 요인에 따라 다릅니다. 간단한 경험적 방법은 사용 가능한 CPU 코어 수를 사용하는 것입니다. 그러나 `prefetch` 및 `interleave` 변환의 경우와 같이 `map` 변환은 `tf.data` 런타임에 사용할 병렬 처리 수준에 대한 결정을 위임하는 `tf.data.AUTOTUNE`을 지원합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "GSkKetpx-jLD"
      },
      "outputs": [],
      "source": [
        "def mapped_function(s):\n",
        "    # Do some hard pre-processing\n",
        "    tf.py_function(lambda: time.sleep(0.03), [], ())\n",
        "    return s"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wiU7W_QC-jLI"
      },
      "source": [
        "#### 순차적 매핑\n",
        "\n",
        "병렬 처리 없이 `map` 변환을 기본 예제로 사용하여 시작하십시오."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "ZSBvDpJG-jLL",
        "outputId": "3bdcd810-288e-4c5b-e233-0d254e450427",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.6725968880000011\n"
          ]
        }
      ],
      "source": [
        "benchmark(\n",
        "    ArtificialDataset()\n",
        "    .map(mapped_function)\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ngwMTDb6-jLR"
      },
      "source": [
        "![순차적 매핑](https://www.tensorflow.org/guide/images/data_performance/sequential_map.svg)\n",
        "\n",
        "[추상적 접근](#The-naive-approach)의 경우 여기에서 열기, 읽기, 전처리(매핑) 및 단일 반복을 위해 훈련 스텝에 소요된 시간이 합산됩니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U-10PE1D-jLU"
      },
      "source": [
        "#### 병렬 매핑\n",
        "\n",
        "이제 동일한 전처리 함수를 사용하지만 여러 샘플에 병렬로 적용하십시오."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "F8AYLZbg-jLV",
        "outputId": "bd9fbcf3-61b0-4d41-80fa-cc0e7c49c017",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.639199185999999\n"
          ]
        }
      ],
      "source": [
        "benchmark(\n",
        "    ArtificialDataset()\n",
        "    .map(\n",
        "        mapped_function,\n",
        "        num_parallel_calls=tf.data.AUTOTUNE\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-MoJklzP-jLe"
      },
      "source": [
        "![병렬 매핑](https://www.tensorflow.org/guide/images/data_performance/parallel_map.svg)\n",
        "\n",
        "이제 그림(plot)에서 전처리 단계가 겹치므로 단일 반복의 전체 시간이 줄어 듭니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZY1Q9kJO-jLh"
      },
      "source": [
        "### 캐시하기\n",
        "\n",
        "`tf.data.Dataset.cache` 변환은 데이터셋을 메모리 또는 로컬 저장소에 캐시할 수 있습니다. 이렇게하면 각 에포크 동안 실행되는 일부 작업(파일 열기 및 데이터 읽기 등)이 저장됩니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "xieLApaI-jLi",
        "outputId": "eeb5fd2b-0d3a-4739-d291-a25606fd4158",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.503489524999992\n"
          ]
        }
      ],
      "source": [
        "benchmark(\n",
        "    ArtificialDataset()\n",
        "    .map(  # Apply time consuming operations before cache\n",
        "        mapped_function\n",
        "    ).cache(\n",
        "    ),\n",
        "    5\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KeMgW9XI-jLn"
      },
      "source": [
        "![캐시된 데이터셋](https://www.tensorflow.org/guide/images/data_performance/cached_dataset.svg)\n",
        "\n",
        "데이터셋을 캐시할 때, `cache` 이전의 변환(파일 열기 및 데이터 읽기와 같은)은 첫 번째 에포크 동안에만 실행됩니다. 다음 에포크에는 `cache` 변환에 의해 캐시된 데이터를 재사용 할 것입니다.\n",
        "\n",
        "`map` 변환에 전달된 사용자 정의 함수가 비싸면 결과 데이터셋이 여전히 메모리 또는 로컬 스토리지에 적합할 수 있는 한 `map` 변환 후 `cache` 변환을 적용합니다.사용자 정의 함수가 캐시 용량을 넘어서 데이터셋을 저장하는 데 필요한 공간을 늘리면 `cache` 변환 후 데이터셋을 적용하거나 훈련 작업 전에 데이터를 전처리하여 리소스 사용량을 줄입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i3NtGI3r-jLp"
      },
      "source": [
        "### 매핑 벡터화\n",
        "\n",
        "`map` 변환으로 전달된 사용자 정의 함수를 호출하면 사용자 정의 함수의 스케줄링 및 실행과 관련된 오버헤드가 있습니다. 사용자 정의 함수를 벡터화(즉, 한 번에 여러 입력에 대해 작동하도록)하고 `맵`을 변환하기 *전에* `배치` 변환을 적용하는 것이 좋습니다.\n",
        "\n",
        "이 모범 사례를 설명하는 데 인공 데이터셋은 적합하지 않습니다. 스케줄링 지연은 약 10 마이크로초(10e-6초)로, `ArtificialDataset`에 사용된 수십 밀리초보다 훨씬 짧으므로 그 영향을 보기가 어렵습니다.\n",
        "\n",
        "이 예제에서는 기본 `tf.data.Dataset.range` 함수를 사용하고 훈련 루프를 가장 간단한 형태로 단순화하십시오."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "xqtiYPmb-jLt"
      },
      "outputs": [],
      "source": [
        "fast_dataset = tf.data.Dataset.range(10000)\n",
        "\n",
        "def fast_benchmark(dataset, num_epochs=2):\n",
        "    start_time = time.perf_counter()\n",
        "    for _ in tf.data.Dataset.range(num_epochs):\n",
        "        for _ in dataset:\n",
        "            pass\n",
        "    tf.print(\"Execution time:\", time.perf_counter() - start_time)\n",
        "\n",
        "def increment(x):\n",
        "    return x+1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fj2gmsMT-jL5"
      },
      "source": [
        "#### 스칼라 매핑"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "Imn3SslJ-jMA",
        "outputId": "0e018664-4055-4e8f-9eff-bb1786127a01",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 1.2726749760000047\n"
          ]
        }
      ],
      "source": [
        "fast_benchmark(\n",
        "    fast_dataset\n",
        "    # Apply function one item at a time\n",
        "    .map(increment)\n",
        "    # Batch\n",
        "    .batch(256)\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BWUNbPqv-jMF"
      },
      "source": [
        "![스칼라 맵](https://www.tensorflow.org/guide/images/data_performance/scalar_map.svg)\n",
        "\n",
        "위의 그림은 (샘플이 적은) 진행 상황을 보여줍니다. 매핑된 함수가 각 샘플에 적용되어 있음을 알 수 있습니다. 이 기능은 매우 빠르지만 시간 성능에 영향을 주는 약간의 오버헤드가 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tDVSM0A--jMG"
      },
      "source": [
        "#### 매핑 벡터화됨"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "nAw1mDLw-jMI",
        "outputId": "698cdffc-27e9-48b4-9d39-09e99464c9be",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.24088996000000407\n"
          ]
        }
      ],
      "source": [
        "fast_benchmark(\n",
        "    fast_dataset\n",
        "    .batch(256)\n",
        "    # Apply function on a batch of items\n",
        "    # The tf.Tensor.__add__ method already handle batches\n",
        "    .map(increment)\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DbMteMY9-jMO"
      },
      "source": [
        "![벡터화된 맵](https://www.tensorflow.org/guide/images/data_performance/vectorized_map.svg)\n",
        "\n",
        "이번에는 매핑된 함수가 한 번 호출되어 샘플 배치에 적용됩니다. 이 함수를 실행하는 데 시간이 더 걸릴 수 있지만 오버헤드는 한 번만 나타나므로 전체 시간 성능이 향상됩니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hfueG0Wj-jMR"
      },
      "source": [
        "### 메모리 사용량(footprint) 줄이기\n",
        "\n",
        "`interleave`, `prefetch`, `shuffle`을 포함한 많은 변환은 요소들의 내부 버퍼를 유지합니다. 사용자 정의 함수가 `map` 변환에 전달된 경우 요소의 크기가 변경되고 맵 변환의 순서와 버퍼 요소가 메모리 사용에 영향을 줍니다. 일반적으로 순서를 다르게 하는 것이 성능에 도움이 되는 경우 메모리 사용량이 낮아지는 순서를 선택하는 것이 좋습니다.\n",
        "\n",
        "#### 부분 계산 캐싱\n",
        "\n",
        "이 변환으로 인해 데이터가 너무 커서 메모리에 맞지 않는 경우를 제외하고 `map` 변환 후 데이터셋을 캐시하는 것이 좋습니다. 매핑된 기능을 시간 소모적인 부분과 메모리 소모적인 부분의 두 부분으로 나눌 수 있다면 교환이 성사될 수 있습니다. 이 경우 아래와 같이 변환을 연결할 수 있습니다:\n",
        "\n",
        "```python\n",
        "dataset.map(time_consuming_mapping).cache().map(memory_consuming_mapping)\n",
        "```\n",
        "\n",
        "이런 식으로 시간이 많이 걸리는 부분은 첫 번째 에포크(epoch) 동안에만 실행되며 너무 많은 캐시 공간을 사용하지 않습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MYOHG69M-jMT"
      },
      "source": [
        "## 가장 좋은 예제 요약\n",
        "\n",
        "다음은 성능이 좋은 텐서플로 입력 파이프라인을 설계하기 위한 가장 좋은 예제를 요약한 것입니다:\n",
        "\n",
        "- [`prefetch` 변환](#Pipelining)을 사용하여 프로듀서와 컨슈머의 작업을 오버랩하세요.\n",
        "- `interleave` 변환을 이용해 [데이터 읽기 변환을 병렬화하세요](#Parallelizing-data-extraction).\n",
        "- `num_parallel_calls` 매개변수를 설정하여 [`map` 변환을 병렬 처리하세요](#Parallelizing-data-transformation).\n",
        "- 데이터가 메모리에 저장될 수 있는 경우, [`cache` 변환을 사용](#Caching)하여 첫 번째 에포크동안 데이터를 메모리에 캐시하세요.\n",
        "- `map` 변환에 전달된 [사용자 정의 함수를 벡터화](#Map-and-batch)하세요.\n",
        "- `interleave`, `prefetch`, 그리고 `shuffle` 변환을 적용하여 [메모리 사용을 줄이세요](#Reducing-memory-footprint)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mP_EMFsQ-jMU"
      },
      "source": [
        "## 그림 재현\n",
        "\n",
        "참고: 이 노트북의 나머지 부분은 위의 그림을 재현하는 방법에 대한 것이며, 이 코드로 자유롭게 놀아볼 수 있지만 이해하는 것은 이 자습서의 필수적인 부분이 아닙니다.\n",
        "\n",
        "`tf.data.Dataset` API에 대해 더 깊이 이해하기 위해 자신만의 파이프라인을 사용할 수 있습니다. 다음은 이 안내서의 이미지를 그리는 데 사용되는 코드입니다. 다음과 같은 일반적인 어려움에 대한 해결 방법을 보여주는 좋은 출발점이 될 수 있습니다:\n",
        "\n",
        "- 실행 시간 재현성;\n",
        "- 매핑 된 기능 즉시 실행;\n",
        "- `interleave` 변환 호출 가능."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "7M_jFLer-jMV"
      },
      "outputs": [],
      "source": [
        "import itertools\n",
        "from collections import defaultdict\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z3pjnxtK-jMa"
      },
      "source": [
        "### 데이터셋\n",
        "\n",
        "`ArtificialDataset`과 비슷하게 각 단계에서 소요된 시간을 리턴하는 데이터셋을 빌드할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "OgGl4U7t-jMc"
      },
      "outputs": [],
      "source": [
        "class TimeMeasuredDataset(tf.data.Dataset):\n",
        "    # OUTPUT: (steps, timings, counters)\n",
        "    OUTPUT_TYPES = (tf.dtypes.string, tf.dtypes.float32, tf.dtypes.int32)\n",
        "    OUTPUT_SHAPES = ((2, 1), (2, 2), (2, 3))\n",
        "\n",
        "    _INSTANCES_COUNTER = itertools.count()  # Number of datasets generated\n",
        "    _EPOCHS_COUNTER = defaultdict(itertools.count)  # Number of epochs done for each dataset\n",
        "\n",
        "    def _generator(instance_idx, num_samples):\n",
        "        epoch_idx = next(TimeMeasuredDataset._EPOCHS_COUNTER[instance_idx])\n",
        "\n",
        "        # Opening the file\n",
        "        open_enter = time.perf_counter()\n",
        "        time.sleep(0.03)\n",
        "        open_elapsed = time.perf_counter() - open_enter\n",
        "\n",
        "        for sample_idx in range(num_samples):\n",
        "            # Reading data (line, record) from the file\n",
        "            read_enter = time.perf_counter()\n",
        "            time.sleep(0.015)\n",
        "            read_elapsed = time.perf_counter() - read_enter\n",
        "\n",
        "            yield (\n",
        "                [(\"Open\",), (\"Read\",)],\n",
        "                [(open_enter, open_elapsed), (read_enter, read_elapsed)],\n",
        "                [(instance_idx, epoch_idx, -1), (instance_idx, epoch_idx, sample_idx)]\n",
        "            )\n",
        "            open_enter, open_elapsed = -1., -1.  # Negative values will be filtered\n",
        "\n",
        "\n",
        "    def __new__(cls, num_samples=3):\n",
        "        return tf.data.Dataset.from_generator(\n",
        "            cls._generator,\n",
        "            output_types=cls.OUTPUT_TYPES,\n",
        "            output_shapes=cls.OUTPUT_SHAPES,\n",
        "            args=(next(cls._INSTANCES_COUNTER), num_samples)\n",
        "        )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YQqDP4jk-jMj"
      },
      "source": [
        "이 데이터셋은 `[[2, 1], [2, 2], [2, 3]]`의 크기와 `[tf.dtypes.string, tf.dtypes.float32, tf.dtypes.int32]`의 타입을 가진 샘플을 제공합니다. 각 샘플은:\n",
        "\n",
        "```\n",
        "(\n",
        "  [(\"Open\"), (\"Read\")],\n",
        "  [(t0, d), (t0, d)],\n",
        "  [(i, e, -1), (i, e, s)]\n",
        ")\n",
        "```\n",
        "\n",
        "이며,\n",
        "\n",
        "- `Open`과 `Read`는 스텝 식별자\n",
        "- `t0`는 해당 스텝이 시작된 타임스탬프\n",
        "- `d`는 해당 스텝에서 소비된 시간\n",
        "- `i`는 인스턴스의 인덱스\n",
        "- `e`는 에포크 인덱스(데이터셋이 반복된 횟수)\n",
        "- `s`는 샘플 인덱스입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQK913bB-jMm"
      },
      "source": [
        "### 반복 루프\n",
        "\n",
        "반복 루프를 조금 더 복잡하게 하여 모든 타이밍을 집계하십시오. 위에서 설명한 대로 샘플을 생성하는 데이터셋에서만 작동합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "zAy-K_Cq-jMn"
      },
      "outputs": [],
      "source": [
        "def timelined_benchmark(dataset, num_epochs=2):\n",
        "    # Initialize accumulators\n",
        "    steps_acc = tf.zeros([0, 1], dtype=tf.dtypes.string)\n",
        "    times_acc = tf.zeros([0, 2], dtype=tf.dtypes.float32)\n",
        "    values_acc = tf.zeros([0, 3], dtype=tf.dtypes.int32)\n",
        "\n",
        "    start_time = time.perf_counter()\n",
        "    for epoch_num in range(num_epochs):\n",
        "        epoch_enter = time.perf_counter()\n",
        "        for (steps, times, values) in dataset:\n",
        "            # Record dataset preparation informations\n",
        "            steps_acc = tf.concat((steps_acc, steps), axis=0)\n",
        "            times_acc = tf.concat((times_acc, times), axis=0)\n",
        "            values_acc = tf.concat((values_acc, values), axis=0)\n",
        "\n",
        "            # Simulate training time\n",
        "            train_enter = time.perf_counter()\n",
        "            time.sleep(0.01)\n",
        "            train_elapsed = time.perf_counter() - train_enter\n",
        "\n",
        "            # Record training informations\n",
        "            steps_acc = tf.concat((steps_acc, [[\"Train\"]]), axis=0)\n",
        "            times_acc = tf.concat((times_acc, [(train_enter, train_elapsed)]), axis=0)\n",
        "            values_acc = tf.concat((values_acc, [values[-1]]), axis=0)\n",
        "\n",
        "        epoch_elapsed = time.perf_counter() - epoch_enter\n",
        "        # Record epoch informations\n",
        "        steps_acc = tf.concat((steps_acc, [[\"Epoch\"]]), axis=0)\n",
        "        times_acc = tf.concat((times_acc, [(epoch_enter, epoch_elapsed)]), axis=0)\n",
        "        values_acc = tf.concat((values_acc, [[-1, epoch_num, -1]]), axis=0)\n",
        "        time.sleep(0.001)\n",
        "\n",
        "    tf.print(\"Execution time:\", time.perf_counter() - start_time)\n",
        "    return {\"steps\": steps_acc, \"times\": times_acc, \"values\": values_acc}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jw_WSQC8-jMs"
      },
      "source": [
        "### 그리기(plotting) 메서드\n",
        "\n",
        "마지막으로, `timelined_benchmark` 함수에 의해 리턴된 값이 주어지면 타임라인을 그릴 수 있는 함수를 정의하십시오."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "1j73RxiP-jMw"
      },
      "outputs": [],
      "source": [
        "def draw_timeline(timeline, title, width=0.5, annotate=False, save=False):\n",
        "    # Remove invalid entries (negative times, or empty steps) from the timelines\n",
        "    invalid_mask = np.logical_and(timeline['times'] > 0, timeline['steps'] != b'')[:,0]\n",
        "    steps = timeline['steps'][invalid_mask].numpy()\n",
        "    times = timeline['times'][invalid_mask].numpy()\n",
        "    values = timeline['values'][invalid_mask].numpy()\n",
        "\n",
        "    # Get a set of different steps, ordered by the first time they are encountered\n",
        "    step_ids, indices = np.stack(np.unique(steps, return_index=True))\n",
        "    step_ids = step_ids[np.argsort(indices)]\n",
        "\n",
        "    # Shift the starting time to 0 and compute the maximal time value\n",
        "    min_time = times[:,0].min()\n",
        "    times[:,0] = (times[:,0] - min_time)\n",
        "    end = max(width, (times[:,0]+times[:,1]).max() + 0.01)\n",
        "\n",
        "    cmap = mpl.cm.get_cmap(\"plasma\")\n",
        "    plt.close()\n",
        "    fig, axs = plt.subplots(len(step_ids), sharex=True, gridspec_kw={'hspace': 0})\n",
        "    fig.suptitle(title)\n",
        "    fig.set_size_inches(17.0, len(step_ids))\n",
        "    plt.xlim(-0.01, end)\n",
        "\n",
        "    for i, step in enumerate(step_ids):\n",
        "        step_name = step.decode()\n",
        "        ax = axs[i]\n",
        "        ax.set_ylabel(step_name)\n",
        "        ax.set_ylim(0, 1)\n",
        "        ax.set_yticks([])\n",
        "        ax.set_xlabel(\"time (s)\")\n",
        "        ax.set_xticklabels([])\n",
        "        ax.grid(which=\"both\", axis=\"x\", color=\"k\", linestyle=\":\")\n",
        "\n",
        "        # Get timings and annotation for the given step\n",
        "        entries_mask = np.squeeze(steps==step)\n",
        "        serie = np.unique(times[entries_mask], axis=0)\n",
        "        annotations = values[entries_mask]\n",
        "\n",
        "        ax.broken_barh(serie, (0, 1), color=cmap(i / len(step_ids)), linewidth=1, alpha=0.66)\n",
        "        if annotate:\n",
        "            for j, (start, width) in enumerate(serie):\n",
        "                annotation = \"\\n\".join([f\"{l}: {v}\" for l,v in zip((\"i\", \"e\", \"s\"), annotations[j])])\n",
        "                ax.text(start + 0.001 + (0.001 * (j % 2)), 0.55 - (0.1 * (j % 2)), annotation,\n",
        "                        horizontalalignment='left', verticalalignment='center')\n",
        "    if save:\n",
        "        plt.savefig(title.lower().translate(str.maketrans(\" \", \"_\")) + \".svg\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xto6GNdO-jM1"
      },
      "source": [
        "### 매핑된 함수용 래퍼(wrappers) 사용\n",
        "\n",
        "eager 컨텍스트에서 매핑된 함수를 실행하려면 `tf.py_function` 호출 내에서 래핑해야 합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "39v7JD4L-jM2"
      },
      "outputs": [],
      "source": [
        "def map_decorator(func):\n",
        "    def wrapper(steps, times, values):\n",
        "        # Use a tf.py_function to prevent auto-graph from compiling the method\n",
        "        return tf.py_function(\n",
        "            func,\n",
        "            inp=(steps, times, values),\n",
        "            Tout=(steps.dtype, times.dtype, values.dtype)\n",
        "        )\n",
        "    return wrapper"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7eJRCinb-jM5"
      },
      "source": [
        "### 파이프라인 비교"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "YwX4ndHE-jM6"
      },
      "outputs": [],
      "source": [
        "_batch_map_num_items = 50\n",
        "\n",
        "def dataset_generator_fun(*args):\n",
        "    return TimeMeasuredDataset(num_samples=_batch_map_num_items)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EwxJT2aR-jNA"
      },
      "source": [
        "#### Naive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "wLKgurx_-jNC",
        "outputId": "c5c1025a-2366-44cb-8a53-7a47dd3a97c1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:From <ipython-input-17-c85330a00c6e>:32: calling DatasetV2.from_generator (from tensorflow.python.data.ops.dataset_ops) with output_types is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use output_signature instead\n",
            "WARNING:tensorflow:From <ipython-input-17-c85330a00c6e>:32: calling DatasetV2.from_generator (from tensorflow.python.data.ops.dataset_ops) with output_shapes is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use output_signature instead\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 20.889541826\n"
          ]
        }
      ],
      "source": [
        "@map_decorator\n",
        "def naive_map(steps, times, values):\n",
        "    map_enter = time.perf_counter()\n",
        "    time.sleep(0.001)  # Time consuming step\n",
        "    time.sleep(0.0001)  # Memory consuming step\n",
        "    map_elapsed = time.perf_counter() - map_enter\n",
        "\n",
        "    return (\n",
        "        tf.concat((steps, [[\"Map\"]]), axis=0),\n",
        "        tf.concat((times, [[map_enter, map_elapsed]]), axis=0),\n",
        "        tf.concat((values, [values[-1]]), axis=0)\n",
        "    )\n",
        "\n",
        "naive_timeline = timelined_benchmark(\n",
        "    tf.data.Dataset.range(2)\n",
        "    .flat_map(dataset_generator_fun)\n",
        "    .map(naive_map)\n",
        "    .batch(_batch_map_num_items, drop_remainder=True)\n",
        "    .unbatch(),\n",
        "    5\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EJqUMDsO-jNG"
      },
      "source": [
        "### Optimized"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "HYHcwabr-jNH",
        "outputId": "41a8ab57-84bc-4e63-f8a5-46edf8143087",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 9.002328111999987\n"
          ]
        }
      ],
      "source": [
        "@map_decorator\n",
        "def time_consuming_map(steps, times, values):\n",
        "    map_enter = time.perf_counter()\n",
        "    time.sleep(0.001 * values.shape[0])  # Time consuming step\n",
        "    map_elapsed = time.perf_counter() - map_enter\n",
        "\n",
        "    return (\n",
        "        tf.concat((steps, tf.tile([[[\"1st map\"]]], [steps.shape[0], 1, 1])), axis=1),\n",
        "        tf.concat((times, tf.tile([[[map_enter, map_elapsed]]], [times.shape[0], 1, 1])), axis=1),\n",
        "        tf.concat((values, tf.tile([[values[:][-1][0]]], [values.shape[0], 1, 1])), axis=1)\n",
        "    )\n",
        "\n",
        "\n",
        "@map_decorator\n",
        "def memory_consuming_map(steps, times, values):\n",
        "    map_enter = time.perf_counter()\n",
        "    time.sleep(0.0001 * values.shape[0])  # Memory consuming step\n",
        "    map_elapsed = time.perf_counter() - map_enter\n",
        "\n",
        "    # Use tf.tile to handle batch dimension\n",
        "    return (\n",
        "        tf.concat((steps, tf.tile([[[\"2nd map\"]]], [steps.shape[0], 1, 1])), axis=1),\n",
        "        tf.concat((times, tf.tile([[[map_enter, map_elapsed]]], [times.shape[0], 1, 1])), axis=1),\n",
        "        tf.concat((values, tf.tile([[values[:][-1][0]]], [values.shape[0], 1, 1])), axis=1)\n",
        "    )\n",
        "\n",
        "\n",
        "optimized_timeline = timelined_benchmark(\n",
        "    tf.data.Dataset.range(2)\n",
        "    .interleave(  # Parallelize data reading\n",
        "        dataset_generator_fun,\n",
        "        num_parallel_calls=tf.data.AUTOTUNE\n",
        "    )\n",
        "    .batch(  # Vectorize your mapped function\n",
        "        _batch_map_num_items,\n",
        "        drop_remainder=True)\n",
        "    .map(  # Parallelize map transformation\n",
        "        time_consuming_map,\n",
        "        num_parallel_calls=tf.data.AUTOTUNE\n",
        "    )\n",
        "    .cache()  # Cache data\n",
        "    .map(  # Reduce memory usage\n",
        "        memory_consuming_map,\n",
        "        num_parallel_calls=tf.data.AUTOTUNE\n",
        "    )\n",
        "    .prefetch(  # Overlap producer and consumer works\n",
        "        tf.data.AUTOTUNE\n",
        "    )\n",
        "    .unbatch(),\n",
        "    5\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "b_CSUbxL-jNK",
        "outputId": "1869beb3-306a-40ea-cef9-a9d5735ef0c7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 386
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-19-c2085563342f>:17: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n",
            "  cmap = mpl.cm.get_cmap(\"plasma\")\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1700x500 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "draw_timeline(naive_timeline, \"Naive\", 15)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "DoovY7qr-jNR",
        "outputId": "cbe8ec90-aa33-42d7-a382-de86321b98f6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 442
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-19-c2085563342f>:17: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n",
            "  cmap = mpl.cm.get_cmap(\"plasma\")\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1700x600 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "draw_timeline(optimized_timeline, \"Optimized\", 15)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "data_performance.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}