{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "Tce3stUlHN0L"
},
"source": [
"##### Copyright 2019 The TensorFlow Authors."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"cellView": "form",
"execution": {
"iopub.execute_input": "2022-12-14T20:12:39.446173Z",
"iopub.status.busy": "2022-12-14T20:12:39.445805Z",
"iopub.status.idle": "2022-12-14T20:12:39.449773Z",
"shell.execute_reply": "2022-12-14T20:12:39.449225Z"
},
"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": [
""
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "xHxb-dlhMIzW"
},
"source": [
"## 概要\n",
"\n",
"GPU と TPU は、単一のトレーニングステップを実行するために必要な時間を劇的に短縮することができます。ピークパフォーマンスの達成には、現在のステップが終了する前に、次のステップのデータを配信する有効な入力パイプラインが必要となります。柔軟で効率的な入力パイプラインの構築に役立つのが、`tf.data` API です。このドキュメントでは、`tf.data` API を使用して非常に性能の高い TensorFlow 入力パイプラインを構築する方法を説明します。\n",
"\n",
"読み進める前に、「[TensorFlow 入力パイプラインの構築](./data.ipynb)」ガイドに目を通し、`tf.data` API の使用方法を学習してください。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "UhNtHfuxCGVy"
},
"source": [
"## リソース\n",
"\n",
"- [TensorFlow 入力パイプラインの構築](./data.ipynb)\n",
"- `tf.data.Dataset` API\n",
"- TensorFlow プロファイラを使用した tf.data パフォーマンスの分析 "
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MUXex9ctTuDB"
},
"source": [
"## セットアップ"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:39.453338Z",
"iopub.status.busy": "2022-12-14T20:12:39.452996Z",
"iopub.status.idle": "2022-12-14T20:12:41.353890Z",
"shell.execute_reply": "2022-12-14T20:12:41.353207Z"
},
"id": "IqR2PQG4ZaZ0"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 20:12:40.389570: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
"2022-12-14 20:12:40.389666: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
"2022-12-14 20:12:40.389675: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
]
}
],
"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",
"まずは、`ArtificialDataset` という、`tf.data.Dataset` から継承するクラスを定義します。このデータセットは次のことを行います。\n",
"\n",
"- `num_samples` サンプルを生成する（デフォルトは 3）\n",
"- ファイルを開くアクションをシミュレーションするために、最初のアイテムの前にしばらくスリープする\n",
"- ファイルからデータを読み込む操作をシミュレーションするために、各アイテムを生成する前にしばらくスリープする"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:41.358536Z",
"iopub.status.busy": "2022-12-14T20:12:41.357759Z",
"iopub.status.idle": "2022-12-14T20:12:41.362878Z",
"shell.execute_reply": "2022-12-14T20:12:41.362331Z"
},
"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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:41.366320Z",
"iopub.status.busy": "2022-12-14T20:12:41.365759Z",
"iopub.status.idle": "2022-12-14T20:12:41.369445Z",
"shell.execute_reply": "2022-12-14T20:12:41.368911Z"
},
"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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:41.372794Z",
"iopub.status.busy": "2022-12-14T20:12:41.372322Z",
"iopub.status.idle": "2022-12-14T20:12:44.952413Z",
"shell.execute_reply": "2022-12-14T20:12:44.951519Z"
},
"id": "_gP7J1y4-jKY"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.2333629889999429\n"
]
}
],
"source": [
"benchmark(ArtificialDataset())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Lxeat5dH-jKf"
},
"source": [
"内部的には、次のように実行時間が使われています。\n",
"\n",
"\n",
"\n",
"プロットに、トレーニングステップの実行には、次のアクションが伴うことが示されます。\n",
"\n",
"- ファイルが開いていない場合は、ファイルを開く\n",
"- ファイルからデータをフェッチする\n",
"- トレーニングにデータを使用する\n",
"\n",
"ところが、このように単純な同期実装では、パイプラインがデータをフェッチしている間、モデルはアイドル状態となります。その反対に、モデルがトレーニング中である場合、入力パイプラインがアイドル状態となります。したがって、トレーニングのステップ時間は、開いて、読み取り、トレーニングする時間の和であるということになります。\n",
"\n",
"次のセクションでは、この入力パイプラインに基づいて構築し、性能の高い TensorFlow 入力パイプライン設計のベストプラクティスを説明します。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mfukBGNz-jKh"
},
"source": [
"### プリフェッチ\n",
"\n",
"プリフェッチは、トレーニングステップの事前処理とモデルの実行に重なって行われます。モデルがトレーニングステップ `s` を実行する間、入力パイプラインはステップ `s+1` のデータを読み取っています。そうすることで、ステップ時間をトレーニングと、データの抽出にかかる時間の最大時間（和とは反対に）に減少させることができます。\n",
"\n",
"`tf.data` API は、`tf.data.Dataset.prefetch` 変換を提供します。データが生成された時間をデータが消費された時間から切り離すために使用できます。具体的には、この変換は、バックグラウンドのスレッドと内部バッファを使用して、要求される前に入力データセットから要素をプリフェッチします。プリフェッチする要素の数は、単一のトレーニングステップによって消費されるバッチの数と同等（またはそれ以上）である必要があります。この値を手動で調整するか、`tf.data.AUTOTUNE` に設定することができますが、後者の場合、`tf.data` ランタイムによって、ランタイム時に動的に値が調整されます。\n",
"\n",
"プリフェッチ変換は、「プロデューサ」の作業と「コンシューマ」の作業をオーバーラップする機会があればいつでもオーバーラップさせることに注意してください。"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:44.956356Z",
"iopub.status.busy": "2022-12-14T20:12:44.955795Z",
"iopub.status.idle": "2022-12-14T20:12:45.214134Z",
"shell.execute_reply": "2022-12-14T20:12:45.213256Z"
},
"id": "DHpUVqH1-jKi"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.23058086499997898\n"
]
}
],
"source": [
"benchmark(\n",
" ArtificialDataset()\n",
" .prefetch(tf.data.AUTOTUNE)\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "h7z_kzo--jKn"
},
"source": [
"\n",
"\n",
"次に、サンプル 0 でトレーニングセットアップが実行している間、入力パイプラインはサンプル 1 のデータを読み取っているのがわかります。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "52QMKfaY-jKq"
},
"source": [
"### データ抽出の並列化\n",
"\n",
"実世界の状況では、入力データはリモート（Google Cloud Storage や HDFS など）に保管されていることがあります。ローカルとリモートのストレージには、次のような違いがあるため、ローカルでのデータ読み取りに適したデータセットパイプラインは、リモートで読み取られる際にボトルネックとなる可能性があります。\n",
"\n",
"- **最初のバイトまでの時間:** リモートストレージからファイルの最初のバイトを読み取る場合、ロカールストレージからよりもずっと長い時間がかかります。\n",
"- **読み取りのスループット:** リモートストレージの総帯域幅は一般的に大きいため、単一のファイルの読み取りには、この帯域幅のほんのわずかしか使用されません。\n",
"\n",
"さらに、生のバイトがメモリに読み込まれると、データのデシリアライズや復号化する必要も出てくるため（[protobuf](https://developers.google.com/protocol-buffers/) など）、さらに計算が必要となります。このオーバーヘッドは、データの格納場所がローカルであるかリモートであるかに関係なく存在しますが、データのプリフェッチが効果的に行われない場合、リモートの場合に大きくなることがあります。\n",
"\n",
"データ抽出にまつわるさまざまなオーバーヘッドの影響を緩和するために、`tf.data.Dataset.interleave` 変換を使用して、データの読み込みステップをほかのデータセットのコンテンツ（データファイルリーダーなど）とインターリーブしながら並列化することができます。オーバーラップするデータセットの数は、`cycle_length` 引数で指定し、並列化のレベルは `num_parallel_calls` 引数で指定することができます。`prefetch` 変換と同様に、`interleave` 変換も `tf.data.AUTOTUNE` をサポートしているため、どのレベルの並列化を使用するかという判断は `tf.data` ランタイムに委ねられます。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "gs8O8Vbu-jKu"
},
"source": [
"#### 順次インターリーブ\n",
"\n",
"`tf.data.Dataset.interleave` 変換のデフォルトの引数によって、2 つのデータセットからの単一のサンプルが順次、インターリブされます。"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:45.218314Z",
"iopub.status.busy": "2022-12-14T20:12:45.217688Z",
"iopub.status.idle": "2022-12-14T20:12:45.669627Z",
"shell.execute_reply": "2022-12-14T20:12:45.668791Z"
},
"id": "fDH12GiK-jKw"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.9/site-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.\n",
"Instructions for updating:\n",
"Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.4100713720000613\n"
]
}
],
"source": [
"benchmark(\n",
" tf.data.Dataset.range(2)\n",
" .interleave(lambda _: ArtificialDataset())\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "78CsSOnf-jK0"
},
"source": [
"\n",
"\n",
"この図は、`interleave` 変換の動作を示しており、利用できる 2 つのデータセットからサンプルが交互にフェッチされています。ただし、ここでは、パフォーマンスの改善は認められません。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "j3cqqmYl-jK2"
},
"source": [
"#### 並列インターリーブ\n",
"\n",
"では、`interleave` 変換の `num_parallel_calls` 引数を使用してみましょう。これは、複数のデータセットを並列して読み込むため、ファイルが開かれるまでの待機時間が短縮されます。"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:45.673586Z",
"iopub.status.busy": "2022-12-14T20:12:45.672973Z",
"iopub.status.idle": "2022-12-14T20:12:46.021668Z",
"shell.execute_reply": "2022-12-14T20:12:46.020719Z"
},
"id": "a3FQcTPY-jK4"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.31014879800000017\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": [
"\n",
"\n",
"今度は、データ実行時間のプロットからわかるように、2 つのデータセットの読み取りが並列化され、総合的なデータ処理時間が短縮されています。"
]
},
{
"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.AUTOTUNE` をサポートしているため、どのレベルの並列化を使用するかという判断は `tf.data` ランタイムに委ねられています。"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:46.025421Z",
"iopub.status.busy": "2022-12-14T20:12:46.025142Z",
"iopub.status.idle": "2022-12-14T20:12:46.029281Z",
"shell.execute_reply": "2022-12-14T20:12:46.028496Z"
},
"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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:46.032904Z",
"iopub.status.busy": "2022-12-14T20:12:46.032444Z",
"iopub.status.idle": "2022-12-14T20:12:46.509823Z",
"shell.execute_reply": "2022-12-14T20:12:46.508898Z"
},
"id": "ZSBvDpJG-jLL"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.4240529329999845\n"
]
}
],
"source": [
"benchmark(\n",
" ArtificialDataset()\n",
" .map(mapped_function)\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ngwMTDb6-jLR"
},
"source": [
"\n",
"\n",
"[単純なアプローチ](#The-naive-approach)について言えば、ステップを開いて読み取り、事前処理（マッピング）を行ってトレーニングする時間が、単一のイテレーションの総和となります。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "U-10PE1D-jLU"
},
"source": [
"#### 並列マッピング\n",
"\n",
"では、同じ事前処理関数を使用して、複数のサンプルで並列に適用してみましょう。"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:46.514087Z",
"iopub.status.busy": "2022-12-14T20:12:46.513504Z",
"iopub.status.idle": "2022-12-14T20:12:46.844108Z",
"shell.execute_reply": "2022-12-14T20:12:46.843214Z"
},
"id": "F8AYLZbg-jLV"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.30054549199996927\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": [
"\n",
"\n",
"データプロットが示すように、事前処理ステップがオーバーラップしたことで、単一のイテレーションにかかる総合時間が短縮されたことがわかります。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ZY1Q9kJO-jLh"
},
"source": [
"### キャッシング\n",
"\n",
"`tf.data.Dataset.cache` 変換は、メモリまたはローカルストレージのいずれかに、データセットをキャッシュすることができるため、各エポック中に一部の操作（ファイルを開いてデータを読み取るなど）が実行されなくなります。"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:46.848615Z",
"iopub.status.busy": "2022-12-14T20:12:46.848010Z",
"iopub.status.idle": "2022-12-14T20:12:47.232845Z",
"shell.execute_reply": "2022-12-14T20:12:47.232163Z"
},
"id": "xieLApaI-jLi"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.3522251550000419\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": [
"\n",
"\n",
"ここでは、データ実行時間プロットは、データセットをキャッシュすると、`cache` 1 の前の変換（ファイルを開いてデータを読み取るなど）は、最初のエポックにのみ実行されることを示しています。次のエポックは、`cache` 変換によってキャッシュされたデータを再利用するようになります。\n",
"\n",
"`map` 変換に渡されるユーザー定義関数が高くつく場合は、`map` 変換の後に `cache` 変換を適用することができますが、これは、キャッシュされるデータセットがメモリやローカルストレージにまだ格納できる場合に限ります。ユーザー定義関数によってデータセットを格納するために必要な容量がキャッシュのキャパシティを超えるほど増加する場合は、`cache` 変換の後に適用するようにするか、トレーニングジョブの前にデータを事前処理することでリソースの使用率を抑えることを検討してください。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "i3NtGI3r-jLp"
},
"source": [
"### マッピングのベクトル化\n",
"\n",
"`map` 変換に渡されたユーザー定義関数を呼び出すと、ユーザー定義関数のスケジューリングと実行に関連するオーバーヘッドが生じます。ユーザー定義関数をベクトル化し（1 つの入力バッチでまとめて操作させる）、`map` 変換の*前*に `batch` 変換を適用してください。\n",
"\n",
"これに適した実践を示すには、artificial データセットは適していません。スケジューリングの遅延は約 10 マイクロ秒（10e-6 秒）であり、`ArtificialDataset` で使用される数十ミリ秒よりはるかに短いため、その影響がわかりづらいからです。\n",
"\n",
"この例では、基本の `tf.data.Dataset.range` 関数を使用し、トレーニングループを最も単純な形態まで単純化します。"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.236751Z",
"iopub.status.busy": "2022-12-14T20:12:47.236116Z",
"iopub.status.idle": "2022-12-14T20:12:47.241117Z",
"shell.execute_reply": "2022-12-14T20:12:47.240556Z"
},
"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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.244517Z",
"iopub.status.busy": "2022-12-14T20:12:47.243977Z",
"iopub.status.idle": "2022-12-14T20:12:47.526271Z",
"shell.execute_reply": "2022-12-14T20:12:47.525543Z"
},
"id": "Imn3SslJ-jMA"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.24833615400007147\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": [
"\n",
"\n",
"上の図は、何が起きているかを示しています（より少ないサンプル数で）。マッピングされた関数が各サンプルに適用されているのがわかります。この関数は非常に高速ですが、時間パフォーマンスに影響するオーバーヘッドがあります。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "tDVSM0A--jMG"
},
"source": [
"#### ベクトル化されたマッピング"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.530020Z",
"iopub.status.busy": "2022-12-14T20:12:47.529459Z",
"iopub.status.idle": "2022-12-14T20:12:47.576200Z",
"shell.execute_reply": "2022-12-14T20:12:47.575551Z"
},
"id": "nAw1mDLw-jMI"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 0.03465816100003849\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": [
"\n",
"\n",
"今度は、マッピングされた関数は一度だけ呼び出され、サンプルのバッチに適用されています。データ実行時間のプロットが示すように、関数の実行にかかる時間は長くなりますが、オーバーヘッドの発生は一度だけであり、総合的な時間パフォーマンスが改善されています。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hfueG0Wj-jMR"
},
"source": [
"### メモリフットプリントの縮小\n",
"\n",
"`interleave`、`prefetch`、および `shuffle` といった多数の変換は、要素の内部バッファにとどまります。`map` 変換に渡されるユーザー定義関数が要素のサイズを変更すると、map 変換の順序付けと、要素をバッファリングする変換によって、メモリ使用率に影響が及びます。通常、パフォーマンスの目的でほかの順序が求められない限り、メモリフットプリントがより少なくなる順序を選択してください。\n",
"\n",
"#### 部分計算のキャッシング\n",
"\n",
"メモリに入りきれないほどのデータに増加する場合を除き、`map` 変換の後にデータセットをキャッシュすることが推奨されます。マッピングされた関数を、時間を消費するものとメモリを消費するものの 2 つに分割できれば、トレードオフを解消することができます。この場合、次のように変換をつなぐことができます。\n",
"\n",
"```python\n",
"dataset.map(time_consuming_mapping).cache().map(memory_consuming_mapping)\n",
"```\n",
"\n",
"こうすることで、時間を消費する部分は最初のエポック中にのみ実行されるようになるため、キャッシュスペースを使いすぎなくて済みます。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MYOHG69M-jMT"
},
"source": [
"## ベストプラクティスのまとめ\n",
"\n",
"性能の高い TensorFlow 入力パイプライン設計のベストプラクティスをまとめてましょう。\n",
"\n",
"- [`prefetch` 変換を使用](#Pipelining)して、プロデューサとコンシューマの作業をオーバーラップさせる。\n",
"- interleave 変換を使用して、データの読み取り変換を並列化 する。\n",
"- num_parallel_calls 引数を設定して、map 変換を並列化interleave、`prefetch`、および `shuffle` 変換を適用する際に、メモリ使用率を低減 する。"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mP_EMFsQ-jMU"
},
"source": [
"## 数値の再現\n",
"\n",
"注意: これ以降のノートブックでは、上記の数値を再現する方法を説明しています。このコードを自由に調整してかまいませんが、このチュートリアルの要点ではないことに留意してください。\n",
"\n",
"`tf.data.Dataset` API の理解をさらに深めるには、独自のパイプラインで調整を試すのがよいでしょう。以下は、このガイドの画像を作成するために使用したコードです。次のような一般的な課題の回避策を示しているため、出発点にはご利用ください。\n",
"\n",
"- 実行時間の再現可能性\n",
"- マッピングされた関数の Eager execution\n",
"- `interleave` 変換のコーラブル"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.579909Z",
"iopub.status.busy": "2022-12-14T20:12:47.579307Z",
"iopub.status.idle": "2022-12-14T20:12:47.925094Z",
"shell.execute_reply": "2022-12-14T20:12:47.924407Z"
},
"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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.929622Z",
"iopub.status.busy": "2022-12-14T20:12:47.928971Z",
"iopub.status.idle": "2022-12-14T20:12:47.935883Z",
"shell.execute_reply": "2022-12-14T20:12:47.935242Z"
},
"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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.939317Z",
"iopub.status.busy": "2022-12-14T20:12:47.938849Z",
"iopub.status.idle": "2022-12-14T20:12:47.946236Z",
"shell.execute_reply": "2022-12-14T20:12:47.945646Z"
},
"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": [
"### 作図方法\n",
"\n",
"最後に、`timelined_benchmark` 関数によって返された値でタイムラインを作図できる関数を定義します。"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.949635Z",
"iopub.status.busy": "2022-12-14T20:12:47.949155Z",
"iopub.status.idle": "2022-12-14T20:12:47.959183Z",
"shell.execute_reply": "2022-12-14T20:12:47.958604Z"
},
"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": [
"### マッピングされた関数にラッパーを使用\n",
"\n",
"マッピングされた関数を Eager コンテキストで実行するには、それらを`tf.py_function` 呼び出し内にラップする必要があります。"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.962486Z",
"iopub.status.busy": "2022-12-14T20:12:47.961910Z",
"iopub.status.idle": "2022-12-14T20:12:47.965532Z",
"shell.execute_reply": "2022-12-14T20:12:47.964973Z"
},
"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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.968438Z",
"iopub.status.busy": "2022-12-14T20:12:47.968190Z",
"iopub.status.idle": "2022-12-14T20:12:47.971311Z",
"shell.execute_reply": "2022-12-14T20:12:47.970767Z"
},
"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": [
"#### 単純"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:12:47.974479Z",
"iopub.status.busy": "2022-12-14T20:12:47.973935Z",
"iopub.status.idle": "2022-12-14T20:13:00.970177Z",
"shell.execute_reply": "2022-12-14T20:13:00.969499Z"
},
"id": "wLKgurx_-jNC"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"WARNING:tensorflow:From /tmpfs/tmp/ipykernel_23190/64197174.py: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"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"WARNING:tensorflow:From /tmpfs/tmp/ipykernel_23190/64197174.py: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"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 12.898758070999975\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": [
"### 最適化"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:13:00.973705Z",
"iopub.status.busy": "2022-12-14T20:13:00.973461Z",
"iopub.status.idle": "2022-12-14T20:13:07.679241Z",
"shell.execute_reply": "2022-12-14T20:13:07.678549Z"
},
"id": "HYHcwabr-jNH"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Execution time: 6.640523429000041\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": {
"execution": {
"iopub.execute_input": "2022-12-14T20:13:07.682563Z",
"iopub.status.busy": "2022-12-14T20:13:07.682247Z",
"iopub.status.idle": "2022-12-14T20:13:08.198754Z",
"shell.execute_reply": "2022-12-14T20:13:08.198106Z"
},
"id": "b_CSUbxL-jNK"
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"draw_timeline(naive_timeline, \"Naive\", 15)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T20:13:08.202753Z",
"iopub.status.busy": "2022-12-14T20:13:08.202067Z",
"iopub.status.idle": "2022-12-14T20:13:08.717821Z",
"shell.execute_reply": "2022-12-14T20:13:08.717126Z"
},
"id": "DoovY7qr-jNR"
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"draw_timeline(optimized_timeline, \"Optimized\", 15)"
]
}
],
"metadata": {
"colab": {
"collapsed_sections": [],
"name": "data_performance.ipynb",
"toc_visible": true
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.16"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
![](\"https://www.tensorflow.org/images/tf_logo_32px.png\"){kind=logo}
TensorFlow.org で表示![](\"https://www.tensorflow.org/images/colab_logo_32px.png\"){kind=logo}
Google Colab で実行![](\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\")
GitHub でソースを表示![](\"https://www.tensorflow.org/images/download_logo_32px.png\"){kind=logo}
ノートブックをダウンロード