Loading_and_Preprocessing_Data_with_TensorFlow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading and Preprocessing Data with TensorFlow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Data API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = tf.range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(10,), dtype=int32, numpy=array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = tf.data.Dataset.from_tensor_slices(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TensorSliceDataset shapes: (), types: tf.int32>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Equivalently:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = tf.data.Dataset.range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<RangeDataset shapes: (), types: tf.int64>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printDS(dataset):\n",
    "    for item in dataset:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(1, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(3, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n",
      "tf.Tensor(5, shape=(), dtype=int64)\n",
      "tf.Tensor(6, shape=(), dtype=int64)\n",
      "tf.Tensor(7, shape=(), dtype=int64)\n",
      "tf.Tensor(8, shape=(), dtype=int64)\n",
      "tf.Tensor(9, shape=(), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "printDS(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = dataset.repeat(3).batch(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([0 1 2 3 4 5 6], shape=(7,), dtype=int64)\n",
      "tf.Tensor([7 8 9 0 1 2 3], shape=(7,), dtype=int64)\n",
      "tf.Tensor([4 5 6 7 8 9 0], shape=(7,), dtype=int64)\n",
      "tf.Tensor([1 2 3 4 5 6 7], shape=(7,), dtype=int64)\n",
      "tf.Tensor([8 9], shape=(2,), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "printDS(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = dataset.map(lambda x: x * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([ 0  2  4  6  8 10 12], shape=(7,), dtype=int64)\n",
      "tf.Tensor([14 16 18  0  2  4  6], shape=(7,), dtype=int64)\n",
      "tf.Tensor([ 8 10 12 14 16 18  0], shape=(7,), dtype=int64)\n",
      "tf.Tensor([ 2  4  6  8 10 12 14], shape=(7,), dtype=int64)\n",
      "tf.Tensor([16 18], shape=(2,), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "printDS(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = dataset.unbatch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n",
      "tf.Tensor(6, shape=(), dtype=int64)\n",
      "tf.Tensor(8, shape=(), dtype=int64)\n",
      "tf.Tensor(10, shape=(), dtype=int64)\n",
      "tf.Tensor(12, shape=(), dtype=int64)\n",
      "tf.Tensor(14, shape=(), dtype=int64)\n",
      "tf.Tensor(16, shape=(), dtype=int64)\n",
      "tf.Tensor(18, shape=(), dtype=int64)\n",
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n",
      "tf.Tensor(6, shape=(), dtype=int64)\n",
      "tf.Tensor(8, shape=(), dtype=int64)\n",
      "tf.Tensor(10, shape=(), dtype=int64)\n",
      "tf.Tensor(12, shape=(), dtype=int64)\n",
      "tf.Tensor(14, shape=(), dtype=int64)\n",
      "tf.Tensor(16, shape=(), dtype=int64)\n",
      "tf.Tensor(18, shape=(), dtype=int64)\n",
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n",
      "tf.Tensor(6, shape=(), dtype=int64)\n",
      "tf.Tensor(8, shape=(), dtype=int64)\n",
      "tf.Tensor(10, shape=(), dtype=int64)\n",
      "tf.Tensor(12, shape=(), dtype=int64)\n",
      "tf.Tensor(14, shape=(), dtype=int64)\n",
      "tf.Tensor(16, shape=(), dtype=int64)\n",
      "tf.Tensor(18, shape=(), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "printDS(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = dataset.filter(lambda x:x< 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n",
      "tf.Tensor(6, shape=(), dtype=int64)\n",
      "tf.Tensor(8, shape=(), dtype=int64)\n",
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n",
      "tf.Tensor(6, shape=(), dtype=int64)\n",
      "tf.Tensor(8, shape=(), dtype=int64)\n",
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n",
      "tf.Tensor(6, shape=(), dtype=int64)\n",
      "tf.Tensor(8, shape=(), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "printDS(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printDS(dataset, take = None):\n",
    "    for item in (dataset.take(take) if take else dataset):\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(0, shape=(), dtype=int64)\n",
      "tf.Tensor(2, shape=(), dtype=int64)\n",
      "tf.Tensor(4, shape=(), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "printDS(dataset, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shuffling the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = tf.data.Dataset.range(10).repeat(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = dataset.shuffle(buffer_size=5, seed = 259).batch(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([4 0 1 5 3 9 2], shape=(7,), dtype=int64)\n",
      "tf.Tensor([7 0 6 1 3 4 7], shape=(7,), dtype=int64)\n",
      "tf.Tensor([8 2 5 9 2 0 4], shape=(7,), dtype=int64)\n",
      "tf.Tensor([5 6 7 6 1 8 8], shape=(7,), dtype=int64)\n",
      "tf.Tensor([9 3], shape=(2,), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "printDS(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you call repeat() on a shuffled dataset, by default it will generate a new order at every iteration. This is generally a good idea, but if you prefer to reuse the same order at each iteration (e.g., for tests or debugging), you can set reshuffle_each_iteration=False."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### INTERLEAVING LINES FROM MULTIPLE FILES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_california_housing\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "housing = fetch_california_housing()\n",
    "X_train_full, X_test, y_train_full, y_test = train_test_split(\n",
    "    housing.data, housing.target.reshape(-1, 1), random_state=259)\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(\n",
    "    X_train_full, y_train_full, random_state=259)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(X_train)\n",
    "X_mean = scaler.mean_\n",
    "X_std = scaler.scale_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "For a very large dataset that does not fit in memory, you will typically want to split it into many files first, then have TensorFlow read these files in parallel. To demonstrate this, let's start by splitting the housing dataset and save it to 20 CSV files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_to_multiple_csv_files(data, name_prefix, header=None, n_parts=10):\n",
    "    import os\n",
    "    housing_dir = os.path.join(\"datasets\", \"housing\")\n",
    "    os.makedirs(housing_dir, exist_ok=True)\n",
    "    path_format = os.path.join(housing_dir, \"my_{}_{:02d}.csv\")\n",
    "\n",
    "    filepaths = []\n",
    "    m = len(data)\n",
    "    for file_idx, row_indices in enumerate(np.array_split(np.arange(m), n_parts)):\n",
    "        part_csv = path_format.format(name_prefix, file_idx)\n",
    "        filepaths.append(part_csv)\n",
    "        with open(part_csv, \"wt\", encoding=\"utf-8\") as f:\n",
    "            if header is not None:\n",
    "                f.write(header)\n",
    "                f.write(\"\\n\")\n",
    "            for row_idx in row_indices:\n",
    "                f.write(\",\".join([repr(col) for col in data[row_idx]]))\n",
    "                f.write(\"\\n\")\n",
    "    return filepaths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = np.c_[X_train, y_train]\n",
    "valid_data = np.c_[X_valid, y_valid]\n",
    "test_data = np.c_[X_test, y_test]\n",
    "header_cols = housing.feature_names + [\"MedianHouseValue\"]\n",
    "header = \",\".join(header_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_filepaths = save_to_multiple_csv_files(train_data, \"train\", header, n_parts=20)\n",
    "valid_filepaths = save_to_multiple_csv_files(valid_data, \"valid\", header, n_parts=10)\n",
    "test_filepaths = save_to_multiple_csv_files(test_data, \"test\", header, n_parts=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MedInc</th>\n",
       "      <th>HouseAge</th>\n",
       "      <th>AveRooms</th>\n",
       "      <th>AveBedrms</th>\n",
       "      <th>Population</th>\n",
       "      <th>AveOccup</th>\n",
       "      <th>Latitude</th>\n",
       "      <th>Longitude</th>\n",
       "      <th>MedianHouseValue</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.7857</td>\n",
       "      <td>20.0</td>\n",
       "      <td>5.110187</td>\n",
       "      <td>1.020790</td>\n",
       "      <td>1227.0</td>\n",
       "      <td>2.550936</td>\n",
       "      <td>37.79</td>\n",
       "      <td>-120.98</td>\n",
       "      <td>1.109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7.8774</td>\n",
       "      <td>15.0</td>\n",
       "      <td>6.077160</td>\n",
       "      <td>1.024691</td>\n",
       "      <td>822.0</td>\n",
       "      <td>2.537037</td>\n",
       "      <td>37.21</td>\n",
       "      <td>-122.09</td>\n",
       "      <td>3.949</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.9191</td>\n",
       "      <td>36.0</td>\n",
       "      <td>6.110063</td>\n",
       "      <td>1.059748</td>\n",
       "      <td>711.0</td>\n",
       "      <td>2.235849</td>\n",
       "      <td>38.45</td>\n",
       "      <td>-122.69</td>\n",
       "      <td>1.830</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5.0543</td>\n",
       "      <td>21.0</td>\n",
       "      <td>6.760925</td>\n",
       "      <td>1.146530</td>\n",
       "      <td>1789.0</td>\n",
       "      <td>4.598972</td>\n",
       "      <td>37.31</td>\n",
       "      <td>-121.80</td>\n",
       "      <td>2.320</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.5073</td>\n",
       "      <td>16.0</td>\n",
       "      <td>5.172535</td>\n",
       "      <td>1.036972</td>\n",
       "      <td>1718.0</td>\n",
       "      <td>3.024648</td>\n",
       "      <td>37.41</td>\n",
       "      <td>-121.86</td>\n",
       "      <td>1.789</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   MedInc  HouseAge  AveRooms  AveBedrms  Population  AveOccup  Latitude  \\\n",
       "0  2.7857      20.0  5.110187   1.020790      1227.0  2.550936     37.79   \n",
       "1  7.8774      15.0  6.077160   1.024691       822.0  2.537037     37.21   \n",
       "2  3.9191      36.0  6.110063   1.059748       711.0  2.235849     38.45   \n",
       "3  5.0543      21.0  6.760925   1.146530      1789.0  4.598972     37.31   \n",
       "4  5.5073      16.0  5.172535   1.036972      1718.0  3.024648     37.41   \n",
       "\n",
       "   Longitude  MedianHouseValue  \n",
       "0    -120.98             1.109  \n",
       "1    -122.09             3.949  \n",
       "2    -122.69             1.830  \n",
       "3    -121.80             2.320  \n",
       "4    -121.86             1.789  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "pd.read_csv(train_filepaths[0]).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['datasets/housing/my_train_00.csv',\n",
       " 'datasets/housing/my_train_01.csv',\n",
       " 'datasets/housing/my_train_02.csv',\n",
       " 'datasets/housing/my_train_03.csv',\n",
       " 'datasets/housing/my_train_04.csv',\n",
       " 'datasets/housing/my_train_05.csv',\n",
       " 'datasets/housing/my_train_06.csv',\n",
       " 'datasets/housing/my_train_07.csv',\n",
       " 'datasets/housing/my_train_08.csv',\n",
       " 'datasets/housing/my_train_09.csv',\n",
       " 'datasets/housing/my_train_10.csv',\n",
       " 'datasets/housing/my_train_11.csv',\n",
       " 'datasets/housing/my_train_12.csv',\n",
       " 'datasets/housing/my_train_13.csv',\n",
       " 'datasets/housing/my_train_14.csv',\n",
       " 'datasets/housing/my_train_15.csv',\n",
       " 'datasets/housing/my_train_16.csv',\n",
       " 'datasets/housing/my_train_17.csv',\n",
       " 'datasets/housing/my_train_18.csv',\n",
       " 'datasets/housing/my_train_19.csv']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_filepaths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building an Input Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "filepath_dataset = tf.data.Dataset.list_files(train_filepaths, seed=259)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(b'datasets/housing/my_train_09.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_17.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_10.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_16.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_13.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_19.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_02.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_07.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_05.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_01.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_11.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_12.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_04.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_15.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_14.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_00.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_03.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_18.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_06.csv', shape=(), dtype=string)\n",
      "tf.Tensor(b'datasets/housing/my_train_08.csv', shape=(), dtype=string)\n"
     ]
    }
   ],
   "source": [
    "printDS(filepath_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_readers = 5\n",
    "dataset = filepath_dataset.interleave(\n",
    "    lambda filepath : tf.data.TextLineDataset(filepath).skip(1),\n",
    "    cycle_length=n_readers\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'3.6094,47.0,5.820338983050847,1.064406779661017,868.0,2.942372881355932,34.19,-118.15,1.607'\n",
      "b'5.4605,31.0,5.436813186813187,0.9986263736263736,1924.0,2.642857142857143,32.83,-117.22,1.902'\n",
      "b'2.8924,52.0,5.355353075170843,1.0455580865603644,1169.0,2.662870159453303,36.67,-121.65,1.696'\n",
      "b'6.9261,24.0,7.150753768844221,1.035175879396985,1954.0,3.273031825795645,33.69,-117.95,2.846'\n",
      "b'5.253,5.0,7.093508500772797,1.0517774343122102,4573.0,3.534003091190108,33.96,-117.23,1.633'\n"
     ]
    }
   ],
   "source": [
    "for line in dataset.take(5):\n",
    "    print(line.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For interleaving to work best, it is preferable to have files of identical length; otherwise the ends of the longest files will not be interleaved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_inputs = 8\n",
    "\n",
    "def preprocess(line):\n",
    "    defs = [0.] * n_inputs + [tf.constant([], dtype=tf.float32)]\n",
    "    fields = tf.io.decode_csv(line, record_defaults=defs)\n",
    "    x = tf.stack(fields[:-1])\n",
    "    y = tf.stack(fields[-1:])\n",
    "    return (x - X_mean) / X_std, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(8,), dtype=float32, numpy=\n",
       " array([ 0.17586298,  1.2235422 , -0.04568288, -0.38526082, -0.50061417,\n",
       "        -0.06234207,  0.86403656, -1.3197198 ], dtype=float32)>,\n",
       " <tf.Tensor: shape=(1,), dtype=float32, numpy=array([2.782], dtype=float32)>)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preprocess(b'4.2083,44.0,5.3232,0.9171,846.0,2.3370,37.47,-122.2,2.782')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Putting Everything Together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def csv_reader_dataset(filepaths, repeat=1, n_readers=5,\n",
    "                       n_read_threads=None, shuffle_buffer_size=10000,\n",
    "                       n_parse_threads=5, batch_size=32):\n",
    "    dataset = tf.data.Dataset.list_files(filepaths).repeat(repeat)\n",
    "    dataset = dataset.interleave(\n",
    "        lambda filepath: tf.data.TextLineDataset(filepath).skip(1),\n",
    "        cycle_length=n_readers, num_parallel_calls=n_read_threads)\n",
    "    dataset = dataset.shuffle(shuffle_buffer_size)\n",
    "    dataset = dataset.map(preprocess, num_parallel_calls=n_parse_threads)\n",
    "    dataset = dataset.batch(batch_size)\n",
    "    return dataset.prefetch(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By calling prefetch(1) at the end, we are creating a dataset that will do its best to always be one batch ahead.2 In other words, while our training algorithm is working on one batch, the dataset will already be working in parallel on getting the next batch ready (e.g., reading the data from disk and preprocessing it). This can improve performance dramatically"
   ]
  },
  {
   "attachments": {
    "70037dd6-aa3c-466a-aca5-66de9c4ff721.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:70037dd6-aa3c-466a-aca5-66de9c4ff721.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X =  tf.Tensor(\n",
      "[[-0.39117596 -0.44904044 -0.6613245  -0.05243741  0.8375695  -0.095413\n",
      "  -0.6911488   0.59665453]\n",
      " [-0.62270355  1.303189   -0.31351185  0.14793408 -0.23904042  0.02037749\n",
      "  -0.569358    0.38149974]\n",
      " [ 1.6428047  -0.9269212   0.49610582 -0.29279825  0.64268833  0.01559967\n",
      "  -0.9159965   0.7967991 ]], shape=(3, 8), dtype=float32)\n",
      "y =  tf.Tensor(\n",
      "[[2.631]\n",
      " [1.204]\n",
      " [3.307]], shape=(3, 1), dtype=float32)\n",
      "\n",
      "X =  tf.Tensor(\n",
      "[[-1.2773662   1.1438954  -0.30473638  0.11235887  0.43394902  0.10785495\n",
      "   0.52676684 -0.1088505 ]\n",
      " [-0.3926055   1.7014229   0.1683773  -0.12993701 -0.46077183 -0.01944213\n",
      "  -0.78483504  0.63167953]\n",
      " [ 0.14028397  1.1438954  -0.0677861  -0.00219212 -0.3542368  -0.09053566\n",
      "  -0.73330754  0.5766397 ]], shape=(3, 8), dtype=float32)\n",
      "y =  tf.Tensor(\n",
      "[[0.466  ]\n",
      " [1.2    ]\n",
      " [5.00001]], shape=(3, 1), dtype=float32)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tf.random.set_seed(259)\n",
    "\n",
    "train_set = csv_reader_dataset(train_filepaths, batch_size=3)\n",
    "for X_batch, y_batch in train_set.take(2):\n",
    "    print('X = ', X_batch)\n",
    "    print('y = ', y_batch)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set = csv_reader_dataset(train_filepaths, repeat=None)\n",
    "valid_set = csv_reader_dataset(valid_filepaths)\n",
    "test_set = csv_reader_dataset(test_filepaths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.clear_session()\n",
    "np.random.seed(259)\n",
    "tf.random.set_seed(259)\n",
    "\n",
    "model = keras.models.Sequential([\n",
    "    keras.layers.Dense(30, activation=\"relu\", input_shape=X_train.shape[1:]),\n",
    "    keras.layers.Dense(1),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "362/362 [==============================] - 2s 6ms/step - loss: 2.3222 - val_loss: 1.1523\n",
      "Epoch 2/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 1.0267 - val_loss: 0.7748\n",
      "Epoch 3/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.6872 - val_loss: 0.7106\n",
      "Epoch 4/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.6385 - val_loss: 0.6744\n",
      "Epoch 5/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.6118 - val_loss: 0.6505\n",
      "Epoch 6/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.5972 - val_loss: 0.6296\n",
      "Epoch 7/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.5613 - val_loss: 0.6129\n",
      "Epoch 8/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.5625 - val_loss: 0.5967\n",
      "Epoch 9/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.5327 - val_loss: 0.5867\n",
      "Epoch 10/10\n",
      "362/362 [==============================] - 1s 3ms/step - loss: 0.5344 - val_loss: 0.5729\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7ff2d1e67cc0>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_size = 32\n",
    "model.fit(train_set, steps_per_epoch=len(X_train) // batch_size, epochs=10,\n",
    "          validation_data=valid_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "161/161 [==============================] - 0s 2ms/step - loss: 0.5275\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.5275448560714722"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(test_set, steps=len(X_test) // batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5930161 ],\n",
       "       [2.2513094 ],\n",
       "       [3.767787  ],\n",
       "       ...,\n",
       "       [1.770155  ],\n",
       "       [0.7399308 ],\n",
       "       [0.92326367]], dtype=float32)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_set = test_set.map(lambda X, y: X) # we could instead just pass test_set, Keras would ignore the labels\n",
    "X_new = X_test\n",
    "model.predict(new_set, steps=len(X_new) // batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "● apply()              Applies a transformation function to this dataset.\n",
      "● as_numpy_iterator()  Returns an iterator which converts all elements of the dataset to numpy.\n",
      "● batch()              Combines consecutive elements of this dataset into batches.\n",
      "● cache()              Caches the elements in this dataset.\n",
      "● concatenate()        Creates a `Dataset` by concatenating the given dataset with this dataset.\n",
      "● element_spec()       The type specification of an element of this dataset.\n",
      "● enumerate()          Enumerates the elements of this dataset.\n",
      "● filter()             Filters this dataset according to `predicate`.\n",
      "● flat_map()           Maps `map_func` across this dataset and flattens the result.\n",
      "● from_generator()     Creates a `Dataset` whose elements are generated by `generator`.\n",
      "● from_tensor_slices() Creates a `Dataset` whose elements are slices of the given tensors.\n",
      "● from_tensors()       Creates a `Dataset` with a single element, comprising the given tensors.\n",
      "● interleave()         Maps `map_func` across this dataset, and interleaves the results.\n",
      "● list_files()         A dataset of all files matching one or more glob patterns.\n",
      "● map()                Maps `map_func` across the elements of this dataset.\n",
      "● options()            Returns the options for this dataset and its inputs.\n",
      "● padded_batch()       Combines consecutive elements of this dataset into padded batches.\n",
      "● prefetch()           Creates a `Dataset` that prefetches elements from this dataset.\n",
      "● range()              Creates a `Dataset` of a step-separated range of values.\n",
      "● reduce()             Reduces the input dataset to a single element.\n",
      "● repeat()             Repeats this dataset so each original value is seen `count` times.\n",
      "● shard()              Creates a `Dataset` that includes only 1/`num_shards` of this dataset.\n",
      "● shuffle()            Randomly shuffles the elements of this dataset.\n",
      "● skip()               Creates a `Dataset` that skips `count` elements from this dataset.\n",
      "● take()               Creates a `Dataset` with at most `count` elements from this dataset.\n",
      "● unbatch()            Splits elements of a dataset into multiple elements.\n",
      "● window()             Combines (nests of) input elements into a dataset of (nests of) windows.\n",
      "● with_options()       Returns a new `tf.data.Dataset` with the given options set.\n",
      "● zip()                Creates a `Dataset` by zipping together the given datasets.\n"
     ]
    }
   ],
   "source": [
    "for m in dir(tf.data.Dataset):\n",
    "    if not (m.startswith(\"_\") or m.endswith(\"_\")):\n",
    "        func = getattr(tf.data.Dataset, m)\n",
    "        if hasattr(func, \"__doc__\"):\n",
    "            print(\"● {:21s}{}\".format(m + \"()\", func.__doc__.split(\"\\n\")[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The TFRecord Format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TFRecords are useful when the bottleneck during training is loading and parsing the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.io.TFRecordWriter(\"my_data.tfrecord\") as f:\n",
    "    f.write(b\"This is the first record\")\n",
    "    f.write(b\"And this is the second record\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(b'This is the first record', shape=(), dtype=string)\n",
      "tf.Tensor(b'And this is the second record', shape=(), dtype=string)\n"
     ]
    }
   ],
   "source": [
    "filepaths = ['my_data.tfrecord']\n",
    "dataset = tf.data.TFRecordDataset(filepaths)\n",
    "printDS(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(b'File 0 record 0', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 1 record 0', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 2 record 0', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 0 record 1', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 1 record 1', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 2 record 1', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 0 record 2', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 1 record 2', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 2 record 2', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 3 record 0', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 4 record 0', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 3 record 1', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 4 record 1', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 3 record 2', shape=(), dtype=string)\n",
      "tf.Tensor(b'File 4 record 2', shape=(), dtype=string)\n"
     ]
    }
   ],
   "source": [
    "filepaths = [\"my_test_{}.tfrecord\".format(i) for i in range(5)]\n",
    "for i, filepath in enumerate(filepaths):\n",
    "    with tf.io.TFRecordWriter(filepath) as f:\n",
    "        for j in range(3):\n",
    "            f.write(\"File {} record {}\".format(i, j).encode(\"utf-8\"))\n",
    "\n",
    "dataset = tf.data.TFRecordDataset(filepaths, num_parallel_reads=3)\n",
    "for item in dataset:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = tf.io.TFRecordOptions(compression_type=\"GZIP\")\n",
    "with tf.io.TFRecordWriter(\"my_compressed.tfrecord\", options) as f:\n",
    "    f.write(b\"This is the first record\")\n",
    "    f.write(b\"And this is the second record\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(b'This is the first record', shape=(), dtype=string)\n",
      "tf.Tensor(b'And this is the second record', shape=(), dtype=string)\n"
     ]
    }
   ],
   "source": [
    "dataset = tf.data.TFRecordDataset([\"my_compressed.tfrecord\"],\n",
    "                                  compression_type=\"GZIP\")\n",
    "for item in dataset:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.9 64-bit ('venv': venv)",
   "language": "python",
   "name": "python36964bitvenvvenva66490d71b884a119226d82deedf3358"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}