Lab1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow 2.0 介紹"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/taipeitechmmslab/MMSLAB-TF2/blob/master/Lab1.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://github.com/taipeitechmmslab/MMSLAB-TF2/blob/master/Lab1.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorFlow 的基本型態："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(1, shape=(), dtype=int32)\n",
      "<tf.Variable 'Variable:0' shape=() dtype=int32, numpy=1>\n"
     ]
    }
   ],
   "source": [
    "# 產生一個常數\n",
    "c = tf.constant(1)\n",
    "# 產生一個變數\n",
    "v = tf.Variable(1)\n",
    "print(c)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "零階張量稱為標量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(4, shape=(), dtype=int32)\n",
      "0 階Tensor\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "x = tf.constant(4)\n",
    "print(x)  # 顯示Tensor 常數資訊，Shape=()表示標量，dtype=int32 表示整數\n",
    "print(\"{} 階Tensor\".format(x.ndim))  # 顯示Tensor 的維度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一階張量稱為向量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1階Tensor \n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([1, 2, 3, 4, 5, 6]) \n",
    "print(\"{}階Tensor \".format(x.ndim))    # 顯示Tensor的維度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二階張量稱為矩陣。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2階Tensor \n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([[1, 2, 3], [4, 5, 6]])\n",
    "print(\"{}階Tensor \".format(x.ndim))    # 顯示Tensor的維度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Eager Execution\n",
    "\n",
    "\n",
    "TensorFlow 引入了「Eager Execution」動態圖模式，這個模式在TensorFlow2.0為預設模式，不同與以往的靜態圖模式需要建立計算圖才能執行，Eager Execution模式一旦執行就會返回數值。這使TensorFlow 更容易入門，也使研發更直觀。\n",
    "\n",
    "**Eager Execution 的優點如下：**\n",
    "\n",
    "- 立即返回數值，方便除錯。\n",
    "- 無需 Session.run() 就可以把它們的值返回到 Python。\n",
    "- 為自定義和高階梯度提供強大支援。\n",
    "- 幾乎所有 TensorFlow 運算都適用。\n",
    "\n",
    "\n",
    "**TensorFlow 1.x 和 TensorFlow2.0比較：**\n",
    "```\n",
    "TensorFlow 1.x code:\n",
    ">>> a = tf.constant(1)\n",
    ">>> print(a)\n",
    "Tensor(\"Const_5:0\", shape=(), dtype=int32)\n",
    "\n",
    ">>> sess = tf.Session()\n",
    ">>> print(\"a = {}\".format(sess.run(a)))\n",
    "a = 1\n",
    "\n",
    "\n",
    "TensorFlow 2.0 code:\n",
    ">>> a = tf.constant(1)\n",
    ">>> print(a)\n",
    "tf.Tensor(1, shape=(), dtype=int32)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TensorFlow 基本運算：**\n",
    "\n",
    "Import 必要套件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eager Execution 是否啟動: True\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "print(\"Eager Execution 是否啟動: {}\".format(tf.executing_eagerly()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定義常數 Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 3\n",
      "b = 4\n"
     ]
    }
   ],
   "source": [
    "a = tf.constant(3)\n",
    "b = tf.constant(4)\n",
    "print(\"a = {}\".format(a))\n",
    "print(\"b = {}\".format(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "檢查資料型態"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(3, shape=(), dtype=int32)\n",
      "tf.Tensor(4, shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "基本的運算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a + b = 7\n",
      "a * b = 12\n"
     ]
    }
   ],
   "source": [
    "c = a + b\n",
    "print(\"a + b = {}\".format(c))\n",
    "d = a * b\n",
    "print(\"a * b = {}\".format(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2D Tensor 的運算，在Eager Execution模式下可以混和 Tensor 和 Numpy 做運算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a constant: 2D Tensor\n",
      "a + b = \n",
      "[[2. 2.]\n",
      " [5. 7.]]\n",
      "a * b = \n",
      "[[ 5.  6.]\n",
      " [11. 12.]]\n"
     ]
    }
   ],
   "source": [
    "a = tf.constant([[1., 2.], [3., 4.]], dtype=tf.float32)\n",
    "b = np.array([[1., 0.], [2., 3.]], dtype=np.float32)\n",
    "print(\"a constant: {}D Tensor\".format(a.ndim))\n",
    "\n",
    "c = a + b\n",
    "print(\"a + b = \\n{}\".format(c))\n",
    "d = tf.matmul(a, b)\n",
    "print(\"a * b = \\n{}\".format(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "輸出的結果為 Tensor 格式，我們可以將它轉為 Numpy 格式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[2. 2.]\n",
      " [5. 7.]], shape=(2, 2), dtype=float32)\n",
      "NumpyArray:\n",
      " [[2. 2.]\n",
      " [5. 7.]]\n"
     ]
    }
   ],
   "source": [
    "print(c)\n",
    "print(\"NumpyArray:\\n {}\".format(c.numpy()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "計算梯度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([[2.]], shape=(1, 1), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "w = tf.Variable([[1.0]])\n",
    "with tf.GradientTape() as tape:\n",
    "    loss = w * w\n",
    "\n",
    "grad = tape.gradient(loss, w)\n",
    "print(grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Keras\n",
    "\n",
    "TensorFlow2.0將Keras納為內建高階API，因此不必再而外安裝keras套件，直接透過`tf.keras`指令使用。相較於`tf.keras`和`keras`的差別，`tf.keras`更能全面支援tensorflow的指令與模式，例如支援Eager Exection, tf.data, TPU訓練等等。\n",
    "\n",
    "下面將會介紹兩種最常使用的網路搭建方法：\n",
    "- Sequential Model (序列模型)\n",
    "- Function API (函數式模型)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import 必要套件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.utils import plot_model\n",
    "from IPython.display import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential Model\n",
    "\n",
    "Sequential Model有兩種方法搭建，下面為分類問題範例：輸入為28x28 (拉平為784的一維向量)的影像，輸出為10 (分為十個類別)。\n",
    "\n",
    "**Ex1：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = keras.Sequential(name='Sequential')\n",
    "model.add(layers.Dense(64, activation='relu', input_shape=(784,)))\n",
    "model.add(layers.Dense(64, activation='relu'))\n",
    "model.add(layers.Dense(10, activation='softmax'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex2：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = tf.keras.Sequential([layers.Dense(64, activation='relu', input_shape=(784,)),\n",
    "                             layers.Dense(64, activation='relu'), \n",
    "                             layers.Dense(10, activation='softmax')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "顯示出剛剛搭建的網路"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 產生網絡拓撲圖\n",
    "plot_model(model, to_file='Sequential_Model.png')\n",
    "\n",
    "# 秀出網絡拓撲圖\n",
    "Image('Sequential_Model.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functional API\n",
    "**1. Sample Network：**使用Functional API 一樣可以快速幾行代碼完成和上面Sequential Model 相同的架構。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = keras.Input(shape=(784,), name='Input')\n",
    "hidden1 = layers.Dense(64, activation='relu', name='hidden1')(inputs)\n",
    "hidden2 = layers.Dense(64, activation='relu', name='hidden2')(hidden1)\n",
    "outputs = layers.Dense(10, activation='softmax', name='Output')(hidden2)\n",
    "\n",
    "model = keras.Model(inputs=inputs, outputs=outputs)\n",
    "\n",
    "# 產生網絡拓撲圖\n",
    "plot_model(model, to_file='Functional_API_Sample_Model.png')\n",
    "\n",
    "# 秀出網絡拓撲圖\n",
    "Image('Functional_API_Sample_Model.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multi Input Model：**多輸入單輸出模型，下面的範例為商品價格預測，要預測商品價格，我們需要商品照片、品牌、使用狀況等等。而商品圖片和品牌我們可以經過不同層輸入並做不同的處理，網路架構如下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_input = keras.Input(shape=(28, 28, 1), name='Image_Input')\n",
    "info_input = keras.Input(shape=(1, ), name='Information_Input')\n",
    "\n",
    "hidden1_1 = layers.Conv2D(64, kernel_size=5, strides=2, activation='relu', name='hidden1_1')(img_input)\n",
    "hidden1_2 = layers.Conv2D(32, kernel_size=5, strides=2, activation='relu', name='hidden1_2')(hidden1_1)\n",
    "hidden1_2_ft= layers.Flatten()(hidden1_2)\n",
    "hidden1_3 = layers.Dense(64, activation='relu', name='hidden1_3')(info_input)\n",
    "concat = layers.Concatenate()([hidden1_2_ft, hidden1_3])\n",
    "hidden2 = layers.Dense(64, activation='relu', name='hidden2')(concat)\n",
    "outputs = layers.Dense(1, name='Output')(hidden2)\n",
    "\n",
    "model = keras.Model(inputs=[img_input, info_input], outputs=outputs)\n",
    "\n",
    "# 產生網絡拓撲圖\n",
    "plot_model(model, to_file='Functional_API_Multi_Input_Model.png')\n",
    "\n",
    "# 秀出網絡拓撲圖\n",
    "Image('Functional_API_Multi_Input_Model.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multi Output Network：**單輸入多輸出模型，這種類型的架構在影響處理的領域很長看到，下面舉幾個常見多輸出模型應用例子。\n",
    "\n",
    "- 物件偵測：輸入一張圖像，預測物件位置與物件類別等。\n",
    "- 人像識別：輸入一張圖像，預測圖片中人的性別、年齡等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = keras.Input(shape=(28, 28, 1), name='Input')\n",
    "\n",
    "hidden1 = layers.Conv2D(64, kernel_size=3, activation='relu', name='hidden1')(inputs)\n",
    "hidden2 = layers.Conv2D(64, kernel_size=3, strides=2, activation='relu', name='hidden2')(hidden1)\n",
    "hidden3 = layers.Conv2D(64, kernel_size=3, strides=2, activation='relu', name='hidden3')(hidden2)\n",
    "flatten = layers.Flatten()(hidden3)\n",
    "\n",
    "age_output = layers.Dense(1, name='Age_Output')(flatten)\n",
    "gender_output = layers.Dense(1, name='Gender_Output')(flatten)\n",
    "\n",
    "model = keras.Model(inputs=inputs, outputs=[age_output, gender_output])\n",
    "\n",
    "# 產生網絡拓撲圖\n",
    "plot_model(model, to_file='Functional_API_Multi_Output_Model.png')\n",
    "\n",
    "# 秀出網絡拓撲圖\n",
    "Image('Functional_API_Multi_Output_Model.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multi Input and Multi Output Network：**多輸入多輸出模型，例如天氣預測，輸入可能為當前的天氣資訊和衛星雲圖，而輸出就是降雨機率、溫度和濕度等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image_inputs = keras.Input(shape=(28, 28, 1), name='Image_Input')\n",
    "hidden1 = layers.Conv2D(64, kernel_size=3, activation='relu', name='hidden1')(image_inputs)\n",
    "hidden2 = layers.Conv2D(64, kernel_size=3, strides=2, activation='relu', name='hidden2')(hidden1)\n",
    "hidden3 = layers.Conv2D(64, kernel_size=3, strides=2, activation='relu', name='hidden3')(hidden2)\n",
    "flatten = layers.Flatten()(hidden3)\n",
    "\n",
    "info_inputs = keras.Input(shape=(10, ), name='Info_Input')\n",
    "hidden4 = layers.Dense(64)(info_inputs)\n",
    "\n",
    "concat = layers.Concatenate()([flatten, hidden4])\n",
    "\n",
    "weather_outputs = layers.Dense(1, name='Output1')(concat)\n",
    "temp_outputs = layers.Dense(1, name='Output2')(concat)\n",
    "humidity_outputs = layers.Dense(1, name='Output3')(concat)\n",
    "\n",
    "model = keras.Model(inputs=[image_inputs, info_inputs], \n",
    "                    outputs=[weather_outputs, temp_outputs, humidity_outputs])\n",
    "\n",
    "# 產生網絡拓撲圖\n",
    "plot_model(model, to_file='Functional_API_Multi_Input_Multi_Output_Model.png')\n",
    "\n",
    "# 秀出網絡拓撲圖\n",
    "Image('Functional_API_Multi_Input_Multi_Output_Model.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## tf.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 基本操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.`tf.data.Dataset.from_tensors`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<TensorDataset shapes: (10,), types: tf.int32>\n"
     ]
    }
   ],
   "source": [
    "dataset = tf.data.Dataset.from_tensors(tf.constant([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], shape=(10, )))\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.`tf.data.Dataset.from_tensor_slices`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<TensorSliceDataset shapes: (), types: tf.int32>\n",
      "<TensorSliceDataset shapes: (), types: tf.int32>\n"
     ]
    }
   ],
   "source": [
    "x_data = tf.data.Dataset.from_tensor_slices(tf.constant([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], shape=(10, )))\n",
    "print(x_data)\n",
    "\n",
    "y_data = tf.data.Dataset.from_tensor_slices(tf.constant([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], shape=(10, )))\n",
    "print(y_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.`for loop`讀取數據："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([ 1  2  3  4  5  6  7  8  9 10], shape=(10,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "for data in dataset:\n",
    "    print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 0, y: 0\n",
      "x: 1, y: 2\n",
      "x: 2, y: 4\n",
      "x: 3, y: 6\n",
      "x: 4, y: 8\n",
      "x: 5, y: 10\n",
      "x: 6, y: 12\n",
      "x: 7, y: 14\n",
      "x: 8, y: 16\n",
      "x: 9, y: 18\n"
     ]
    }
   ],
   "source": [
    "for data1, data2 in zip(x_data, y_data):\n",
    "    print('x: {}, y: {}'.format(data1, data2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.`take`：讀取資料"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([ 1  2  3  4  5  6  7  8  9 10], shape=(10,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "for data in dataset:\n",
    "    print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 0, y: 0\n",
      "x: 1, y: 2\n",
      "x: 2, y: 4\n",
      "x: 3, y: 6\n",
      "x: 4, y: 8\n"
     ]
    }
   ],
   "source": [
    "for data1, data2 in zip(x_data.take(5), y_data.take(5)):\n",
    "    print('x: {}, y: {}'.format(data1, data2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 0, y: 0\n",
      "x: 1, y: 2\n",
      "x: 2, y: 4\n",
      "x: 3, y: 6\n",
      "x: 4, y: 8\n",
      "x: 5, y: 10\n",
      "x: 6, y: 12\n",
      "x: 7, y: 14\n",
      "x: 8, y: 16\n",
      "x: 9, y: 18\n"
     ]
    }
   ],
   "source": [
    "for data1, data2 in zip(x_data.take(12), y_data.take(12)):\n",
    "    print('x: {}, y: {}'.format(data1, data2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.`tf.data.Dataset.zip`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<ZipDataset shapes: ((), ()), types: (tf.int32, tf.int32)>\n"
     ]
    }
   ],
   "source": [
    "dataset = tf.data.Dataset.zip((x_data, y_data))\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.`map`：可以使用map來轉換數據"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<MapDataset shapes: (), types: tf.int64>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.data.Dataset.range(10).map(lambda x: x*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7.命名：可以字典方式為elements的組件命名"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<ZipDataset shapes: {x: (), y: ()}, types: {x: tf.int64, y: tf.int64}>\n"
     ]
    }
   ],
   "source": [
    "x = tf.data.Dataset.range(10)\n",
    "y = tf.data.Dataset.range(10).map(lambda x: x*2)\n",
    "\n",
    "dataset = tf.data.Dataset.zip({\"x\": x, \"y\": y})\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 0, y: 0\n",
      "x: 1, y: 2\n",
      "x: 2, y: 4\n",
      "x: 3, y: 6\n",
      "x: 4, y: 8\n",
      "x: 5, y: 10\n",
      "x: 6, y: 12\n",
      "x: 7, y: 14\n",
      "x: 8, y: 16\n",
      "x: 9, y: 18\n"
     ]
    }
   ],
   "source": [
    "for data in dataset.take(10):\n",
    "    print('x: {}, y: {}'.format(data['x'], data['y']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.設定每batch讀取的數量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: [0 1], y: [0 2]\n",
      "x: [2 3], y: [4 6]\n",
      "x: [4 5], y: [ 8 10]\n",
      "x: [6 7], y: [12 14]\n",
      "x: [8 9], y: [16 18]\n"
     ]
    }
   ],
   "source": [
    "dataset = tf.data.Dataset.zip({\"x\": x, \"y\": y}).batch(2)\n",
    "\n",
    "for data in dataset.take(5):\n",
    "    print('x: {}, y: {}'.format(data['x'], data['y']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9.`shuffle`：dataset資料 會被載入buffer中，並從buffer中隨機選取資料出來，取出資料產生的空位會從新的數據替補。而`buffer_size`是設定buffer大小，最好的設定是**大於**或**等於**整個dataset資料個個數。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: [4 5], y: [ 8 10]\n",
      "x: [0 1], y: [0 2]\n",
      "x: [2 3], y: [4 6]\n",
      "x: [8 9], y: [16 18]\n",
      "x: [6 7], y: [12 14]\n"
     ]
    }
   ],
   "source": [
    "dataset = dataset.shuffle(10)\n",
    "for data in dataset.take(5):\n",
    "    print('x: {}, y: {}'.format(data['x'], data['y']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10.`repeat`：當dataset的資料讀取完後就讀會取不到資料，透過設定`repeat(n)`可以重複讀取dataset n次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: [8 9], y: [16 18]\n",
      "x: [6 7], y: [12 14]\n",
      "x: [4 5], y: [ 8 10]\n",
      "x: [0 1], y: [0 2]\n",
      "x: [2 3], y: [4 6]\n",
      "--------------------------------------------------\n",
      "x: [2 3], y: [4 6]\n",
      "x: [6 7], y: [12 14]\n",
      "x: [8 9], y: [16 18]\n",
      "x: [4 5], y: [ 8 10]\n",
      "x: [0 1], y: [0 2]\n",
      "x: [6 7], y: [12 14]\n",
      "x: [4 5], y: [ 8 10]\n",
      "x: [8 9], y: [16 18]\n",
      "x: [0 1], y: [0 2]\n",
      "x: [2 3], y: [4 6]\n"
     ]
    }
   ],
   "source": [
    "for data in dataset.take(10):\n",
    "    print('x: {}, y: {}'.format(data['x'], data['y']))\n",
    "\n",
    "    \n",
    "print('-' * 50)\n",
    "dataset = dataset.repeat(2)\n",
    "for data in dataset.take(10):\n",
    "    print('x: {}, y: {}'.format(data['x'], data['y']))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf2",
   "language": "python",
   "name": "tf2"
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}