utf-8''TFDS-Week2-Question.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "c05P9g5WjizZ"
   },
   "source": [
    "# Classify Structured Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VxyBFc_kKazA"
   },
   "source": [
    "## Import TensorFlow and Other Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9dEreb4QKizj"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow import feature_column\n",
    "\n",
    "from os import getcwd\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KCEhSZcULZ9n"
   },
   "source": [
    "## Use Pandas to Create a Dataframe\n",
    "\n",
    "[Pandas](https://pandas.pydata.org/) is a Python library with many helpful utilities for loading and working with structured data. We will use Pandas to download the dataset and load it into a dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "REZ57BXCLdfG"
   },
   "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>age</th>\n",
       "      <th>sex</th>\n",
       "      <th>cp</th>\n",
       "      <th>trestbps</th>\n",
       "      <th>chol</th>\n",
       "      <th>fbs</th>\n",
       "      <th>restecg</th>\n",
       "      <th>thalach</th>\n",
       "      <th>exang</th>\n",
       "      <th>oldpeak</th>\n",
       "      <th>slope</th>\n",
       "      <th>ca</th>\n",
       "      <th>thal</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>63</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>145</td>\n",
       "      <td>233</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>150</td>\n",
       "      <td>0</td>\n",
       "      <td>2.3</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>fixed</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>67</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>160</td>\n",
       "      <td>286</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>108</td>\n",
       "      <td>1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>normal</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>67</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>120</td>\n",
       "      <td>229</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>129</td>\n",
       "      <td>1</td>\n",
       "      <td>2.6</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>reversible</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>37</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>130</td>\n",
       "      <td>250</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>187</td>\n",
       "      <td>0</td>\n",
       "      <td>3.5</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>41</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>130</td>\n",
       "      <td>204</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>172</td>\n",
       "      <td>0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   age  sex  cp  trestbps  chol  fbs  restecg  thalach  exang  oldpeak  slope  \\\n",
       "0   63    1   1       145   233    1        2      150      0      2.3      3   \n",
       "1   67    1   4       160   286    0        2      108      1      1.5      2   \n",
       "2   67    1   4       120   229    0        2      129      1      2.6      2   \n",
       "3   37    1   3       130   250    0        0      187      0      3.5      3   \n",
       "4   41    0   2       130   204    0        2      172      0      1.4      1   \n",
       "\n",
       "   ca        thal  target  \n",
       "0   0       fixed       0  \n",
       "1   3      normal       1  \n",
       "2   2  reversible       0  \n",
       "3   0      normal       0  \n",
       "4   0      normal       0  "
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filePath = f\"{getcwd()}/../tmp2/heart.csv\"\n",
    "dataframe = pd.read_csv(filePath)\n",
    "dataframe.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "u0zhLtQqMPem"
   },
   "source": [
    "## Split the Dataframe Into Train, Validation, and Test Sets\n",
    "\n",
    "The dataset we downloaded was a single CSV file. We will split this into train, validation, and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YEOpw7LhMYsI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "193 train examples\n",
      "49 validation examples\n",
      "61 test examples\n"
     ]
    }
   ],
   "source": [
    "train, test = train_test_split(dataframe, test_size=0.2)\n",
    "train, val = train_test_split(train, test_size=0.2)\n",
    "print(len(train), 'train examples')\n",
    "print(len(val), 'validation examples')\n",
    "print(len(test), 'test examples')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "84ef46LXMfvu"
   },
   "source": [
    "## Create an Input Pipeline Using `tf.data`\n",
    "\n",
    "Next, we will wrap the dataframes with [tf.data](https://www.tensorflow.org/guide/datasets). This will enable us  to use feature columns as a bridge to map from the columns in the Pandas dataframe to features used to train the model. If we were working with a very large CSV file (so large that it does not fit into memory), we would use tf.data to read it from disk directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXERCISE: A utility method to create a tf.data dataset from a Pandas Dataframe.\n",
    "\n",
    "def df_to_dataset(dataframe, shuffle=True, batch_size=32):\n",
    "    dataframe = dataframe.copy()\n",
    "    # Use Pandas dataframe's pop method to get the list of targets.\n",
    "    labels = dataframe.pop('target')\n",
    "#     dataframe['thal'] = pd.Categorical(dataframe['thal'])\n",
    "#     dataframe['thal'] = dataframe.thal.cat.codes\n",
    "    \n",
    "    # Create a tf.data.Dataset from the dataframe and labels.\n",
    "    ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels.values))\n",
    "    \n",
    "    if shuffle:\n",
    "        # Shuffle dataset.\n",
    "        ds = ds.shuffle(1024)\n",
    "        \n",
    "    # Batch dataset with specified batch_size parameter.\n",
    "    ds = ds.batch(batch_size)\n",
    "    \n",
    "    return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CXbbXkJvMy34"
   },
   "outputs": [],
   "source": [
    "batch_size = 5 # A small batch sized is used for demonstration purposes\n",
    "train_ds = df_to_dataset(train, batch_size=batch_size)\n",
    "val_ds = df_to_dataset(val, shuffle=False, batch_size=batch_size)\n",
    "test_ds = df_to_dataset(test, shuffle=False, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qRLGSMDzM-dl"
   },
   "source": [
    "## Understand the Input Pipeline\n",
    "\n",
    "Now that we have created the input pipeline, let's call it to see the format of the data it returns. We have used a small batch size to keep the output readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CSBo3dUVNFc9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Every feature: ['age', 'sex', 'cp', 'trestbps', 'chol', 'fbs', 'restecg', 'thalach', 'exang', 'oldpeak', 'slope', 'ca', 'thal']\n",
      "A batch of ages: tf.Tensor([57 50 46 60 46], shape=(5,), dtype=int32)\n",
      "A batch of targets: tf.Tensor([1 1 1 0 0], shape=(5,), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "for feature_batch, label_batch in train_ds.take(1):\n",
    "    print('Every feature:', list(feature_batch.keys()))\n",
    "    print('A batch of ages:', feature_batch['age'])\n",
    "    print('A batch of targets:', label_batch )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OT5N6Se-NQsC"
   },
   "source": [
    "We can see that the dataset returns a dictionary of column names (from the dataframe) that map to column values from rows in the dataframe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ttIvgLRaNoOQ"
   },
   "source": [
    "## Create Several Types of Feature Columns\n",
    "\n",
    "TensorFlow provides many types of feature columns. In this section, we will create several types of feature columns, and demonstrate how they transform a column from the dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mxwiHFHuNhmf"
   },
   "outputs": [],
   "source": [
    "# Try to demonstrate several types of feature columns by getting an example.\n",
    "example_batch = next(iter(train_ds))[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0wfLB8Q3N3UH"
   },
   "outputs": [],
   "source": [
    "# A utility method to create a feature column and to transform a batch of data.\n",
    "def demo(feature_column):\n",
    "    feature_layer = layers.DenseFeatures(feature_column, dtype='float64')\n",
    "    print(feature_layer(example_batch).numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q7OEKe82N-Qb"
   },
   "source": [
    "### Numeric Columns\n",
    "\n",
    "The output of a feature column becomes the input to the model (using the demo function defined above, we will be able to see exactly how each column from the dataframe is transformed). A [numeric column](https://www.tensorflow.org/api_docs/python/tf/feature_column/numeric_column) is the simplest type of column. It is used to represent real valued features. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QZTZ0HnHOCxC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[44.]\n",
      " [48.]\n",
      " [52.]\n",
      " [67.]\n",
      " [44.]]\n"
     ]
    }
   ],
   "source": [
    "# EXERCISE: Create a numeric feature column out of 'age' and demo it.\n",
    "age = tf.feature_column.numeric_column('age')\n",
    "\n",
    "demo(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7a6ddSyzOKpq"
   },
   "source": [
    "In the heart disease dataset, most columns from the dataframe are numeric."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IcSxUoYgOlA1"
   },
   "source": [
    "### Bucketized Columns\n",
    "\n",
    "Often, you don't want to feed a number directly into the model, but instead split its value into different categories based on numerical ranges. Consider raw data that represents a person's age. Instead of representing age as a numeric column, we could split the age into several buckets using a [bucketized column](https://www.tensorflow.org/api_docs/python/tf/feature_column/bucketized_column). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wJ4Wt3SAOpTQ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# EXERCISE: Create a bucketized feature column out of 'age' with\n",
    "# the following boundaries and demo it.\n",
    "boundaries = [18, 25, 30, 35, 40, 45, 50, 55, 60, 65]\n",
    "\n",
    "age_buckets = tf.feature_column.bucketized_column(age, boundaries)\n",
    "\n",
    "demo(age_buckets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-me1NKJ4BIEB"
   },
   "source": [
    "Notice the one-hot values above describe which age range each row matches."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r1tArzewPb-b"
   },
   "source": [
    "### Categorical Columns\n",
    "\n",
    "In this dataset, thal is represented as a string (e.g. 'fixed', 'normal', or 'reversible'). We cannot feed strings directly to a model. Instead, we must first map them to numeric values. The categorical vocabulary columns provide a way to represent strings as a one-hot vector (much like you have seen above with age buckets). \n",
    "\n",
    "**Note**: You will probably see some warning messages when running some of the code cell below. These warnings have to do with software updates and should not cause any errors or prevent your code from running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DJ6QnSHkPtOC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4276: IndicatorColumn._variable_shape (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4331: VocabularyListCategoricalColumn._num_buckets (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]\n",
      " [0. 0. 1.]\n",
      " [0. 1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# EXERCISE: Create a categorical vocabulary column out of the\n",
    "# above mentioned categories with the key specified as 'thal'.\n",
    "thal = tf.feature_column.categorical_column_with_vocabulary_list('thal', ['fixed', 'normal', 'reversible'])\n",
    "\n",
    "# EXERCISE: Create an indicator column out of the created categorical column.\n",
    "thal_one_hot = tf.feature_column.indicator_column(thal)\n",
    "\n",
    "demo(thal_one_hot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zQT4zecNBtji"
   },
   "source": [
    "The vocabulary can be passed as a list using [categorical_column_with_vocabulary_list](https://www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_vocabulary_list), or loaded from a file using [categorical_column_with_vocabulary_file](https://www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_vocabulary_file)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LEFPjUr6QmwS"
   },
   "source": [
    "### Embedding Columns\n",
    "\n",
    "Suppose instead of having just a few possible strings, we have thousands (or more) values per category. For a number of reasons, as the number of categories grow large, it becomes infeasible to train a neural network using one-hot encodings. We can use an embedding column to overcome this limitation. Instead of representing the data as a one-hot vector of many dimensions, an [embedding column](https://www.tensorflow.org/api_docs/python/tf/feature_column/embedding_column) represents that data as a lower-dimensional, dense vector in which each cell can contain any number, not just 0 or 1. You can tune the size of the embedding with the `dimension` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hSlohmr2Q_UU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.28724766  0.21722521  0.42196316  0.39877316 -0.34977257 -0.36904067\n",
      "  -0.25824752 -0.12017009]\n",
      " [ 0.06605755  0.311711   -0.18009546 -0.5645003  -0.4292082   0.00976347\n",
      "   0.08982086  0.09808949]\n",
      " [ 0.29693002 -0.0981563  -0.24770111 -0.5202013  -0.11236827 -0.6415816\n",
      "   0.58798677 -0.24337412]\n",
      " [ 0.29693002 -0.0981563  -0.24770111 -0.5202013  -0.11236827 -0.6415816\n",
      "   0.58798677 -0.24337412]\n",
      " [ 0.06605755  0.311711   -0.18009546 -0.5645003  -0.4292082   0.00976347\n",
      "   0.08982086  0.09808949]]\n"
     ]
    }
   ],
   "source": [
    "# EXERCISE: Create an embedding column out of the categorical\n",
    "# vocabulary you just created (thal). Set the size of the \n",
    "# embedding to 8, by using the dimension parameter.\n",
    "\n",
    "thal_embedding = tf.feature_column.embedding_column(thal, 8)\n",
    "\n",
    "\n",
    "demo(thal_embedding)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "urFCAvTVRMpB"
   },
   "source": [
    "### Hashed Feature Columns\n",
    "\n",
    "Another way to represent a categorical column with a large number of values is to use a [categorical_column_with_hash_bucket](https://www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_hash_bucket). This feature column calculates a hash value of the input, then selects one of the `hash_bucket_size` buckets to encode a string. When using this column, you do not need to provide the vocabulary, and you can choose to make the number of hash buckets significantly smaller than the number of actual categories to save space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YHU_Aj2nRRDC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4331: HashedCategoricalColumn._num_buckets (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# EXERCISE: Create a hashed feature column with 'thal' as the key and \n",
    "# 1000 hash buckets.\n",
    "thal_hashed = tf.feature_column.categorical_column_with_hash_bucket('thal', 1000)\n",
    "\n",
    "demo(feature_column.indicator_column(thal_hashed))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fB94M27DRXtZ"
   },
   "source": [
    "### Crossed Feature Columns\n",
    "Combining features into a single feature, better known as [feature crosses](https://developers.google.com/machine-learning/glossary/#feature_cross), enables a model to learn separate weights for each combination of features. Here, we will create a new feature that is the cross of age and thal. Note that `crossed_column` does not build the full table of all possible combinations (which could be very large). Instead, it is backed by a `hashed_column`, so you can choose how large the table is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oaPVERd9Rep6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4331: CrossedColumn._num_buckets (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# EXERCISE: Create a crossed column using the bucketized column (age_buckets),\n",
    "# the categorical vocabulary column (thal) previously created, and 1000 hash buckets.\n",
    "crossed_feature = tf.feature_column.crossed_column([age_buckets, thal], 1000)\n",
    "\n",
    "demo(feature_column.indicator_column(crossed_feature))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ypkI9zx6Rj1q"
   },
   "source": [
    "## Choose Which Columns to Use\n",
    "\n",
    "We have seen how to use several types of feature columns. Now we will use them to train a model. The goal of this exercise is to show you the complete code needed to work with feature columns. We have selected a few columns to train our model below arbitrarily.\n",
    "\n",
    "If your aim is to build an accurate model, try a larger dataset of your own, and think carefully about which features are the most meaningful to include, and how they should be represented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Eu8bJWmCScfC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "age           int64\n",
       "sex           int64\n",
       "cp            int64\n",
       "trestbps      int64\n",
       "chol          int64\n",
       "fbs           int64\n",
       "restecg       int64\n",
       "thalach       int64\n",
       "exang         int64\n",
       "oldpeak     float64\n",
       "slope         int64\n",
       "ca            int64\n",
       "thal         object\n",
       "target        int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataframe.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2pV4tSI3SkuX"
   },
   "source": [
    "You can use the above list of column datatypes to map the appropriate feature column to every column in the dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4PlLY7fORuzA"
   },
   "outputs": [],
   "source": [
    "# EXERCISE: Fill in the missing code below\n",
    "feature_columns = []\n",
    "\n",
    "# Numeric Cols.\n",
    "# Create a list of numeric columns. Use the following list of columns\n",
    "# that have a numeric datatype: ['age', 'trestbps', 'chol', 'thalach', 'oldpeak', 'slope', 'ca'].\n",
    "numeric_columns = ['age', 'trestbps', 'chol', 'thalach', 'oldpeak', 'slope', 'ca']\n",
    "\n",
    "for header in numeric_columns:\n",
    "    # Create a numeric feature column  out of the header.\n",
    "    numeric_feature_column = tf.feature_column.numeric_column(header)\n",
    "    \n",
    "    feature_columns.append(numeric_feature_column)\n",
    "\n",
    "# Bucketized Cols.\n",
    "# Create a bucketized feature column out of the age column (numeric column)\n",
    "# that you've already created. Use the following boundaries:\n",
    "# [18, 25, 30, 35, 40, 45, 50, 55, 60, 65]\n",
    "age_buckets = tf.feature_column.bucketized_column(feature_columns[0], boundaries)\n",
    "\n",
    "feature_columns.append(age_buckets)\n",
    "\n",
    "# Indicator Cols.\n",
    "# Create a categorical vocabulary column out of the categories\n",
    "# ['fixed', 'normal', 'reversible'] with the key specified as 'thal'.\n",
    "thal = tf.feature_column.categorical_column_with_vocabulary_list('thal', ['fixed', 'normal', 'reversible'])\n",
    "\n",
    "# Create an indicator column out of the created thal categorical column\n",
    "thal_one_hot = tf.feature_column.indicator_column(thal)\n",
    "\n",
    "feature_columns.append(thal_one_hot)\n",
    "\n",
    "# Embedding Cols.\n",
    "# Create an embedding column out of the categorical vocabulary you\n",
    "# just created (thal). Set the size of the embedding to 8, by using\n",
    "# the dimension parameter.\n",
    "thal_embedding = tf.feature_column.embedding_column(thal, 8)\n",
    "\n",
    "feature_columns.append(thal_embedding)\n",
    "\n",
    "# Crossed Cols.\n",
    "# Create a crossed column using the bucketized column (age_buckets),\n",
    "# the categorical vocabulary column (thal) previously created, and 1000 hash buckets.\n",
    "crossed_feature = tf.feature_column.crossed_column([age_buckets, thal], 1000)\n",
    "\n",
    "# Create an indicator column out of the crossed column created above to one-hot encode it.\n",
    "crossed_feature = tf.feature_column.indicator_column(crossed_feature)\n",
    "\n",
    "feature_columns.append(crossed_feature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M-nDp8krS_ts"
   },
   "source": [
    "### Create a Feature Layer\n",
    "\n",
    "Now that we have defined our feature columns, we will use a [DenseFeatures](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/layers/DenseFeatures) layer to input them to our Keras model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6o-El1R2TGQP"
   },
   "outputs": [],
   "source": [
    "# EXERCISE: Create a Keras DenseFeatures layer and pass the feature_columns you just created.\n",
    "feature_layer = tf.keras.layers.DenseFeatures(feature_columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8cf6vKfgTH0U"
   },
   "source": [
    "Earlier, we used a small batch size to demonstrate how feature columns worked. We create a new input pipeline with a larger batch size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gcemszoGSse_"
   },
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "train_ds = df_to_dataset(train, batch_size=batch_size)\n",
    "val_ds = df_to_dataset(val, shuffle=False, batch_size=batch_size)\n",
    "test_ds = df_to_dataset(test, shuffle=False, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bBx4Xu0eTXWq"
   },
   "source": [
    "## Create, Compile, and Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_YJPPb3xTPeZ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Layer sequential is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n",
      "Epoch 1/100\n",
      "7/7 [==============================] - 4s 627ms/step - loss: 1.9296 - accuracy: 0.6114 - val_loss: 0.0000e+00 - val_accuracy: 0.0000e+00\n",
      "Epoch 2/100\n",
      "7/7 [==============================] - 0s 57ms/step - loss: 1.3997 - accuracy: 0.5699 - val_loss: 0.5146 - val_accuracy: 0.7551\n",
      "Epoch 3/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.8760 - accuracy: 0.7358 - val_loss: 0.5962 - val_accuracy: 0.6327\n",
      "Epoch 4/100\n",
      "7/7 [==============================] - 0s 57ms/step - loss: 0.6013 - accuracy: 0.7254 - val_loss: 0.5584 - val_accuracy: 0.7755\n",
      "Epoch 5/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.5858 - accuracy: 0.7461 - val_loss: 1.2739 - val_accuracy: 0.4082\n",
      "Epoch 6/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.8936 - accuracy: 0.6218 - val_loss: 0.8761 - val_accuracy: 0.7551\n",
      "Epoch 7/100\n",
      "7/7 [==============================] - 0s 44ms/step - loss: 0.7993 - accuracy: 0.6995 - val_loss: 0.3965 - val_accuracy: 0.7959\n",
      "Epoch 8/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.6975 - accuracy: 0.7098 - val_loss: 0.3979 - val_accuracy: 0.8163\n",
      "Epoch 9/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5593 - accuracy: 0.7617 - val_loss: 0.4653 - val_accuracy: 0.7551\n",
      "Epoch 10/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.4394 - accuracy: 0.7927 - val_loss: 0.4132 - val_accuracy: 0.7755\n",
      "Epoch 11/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5097 - accuracy: 0.7720 - val_loss: 0.4286 - val_accuracy: 0.8163\n",
      "Epoch 12/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4794 - accuracy: 0.7824 - val_loss: 0.3486 - val_accuracy: 0.8571\n",
      "Epoch 13/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4476 - accuracy: 0.7772 - val_loss: 0.4103 - val_accuracy: 0.8163\n",
      "Epoch 14/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.4218 - accuracy: 0.7824 - val_loss: 0.3641 - val_accuracy: 0.7755\n",
      "Epoch 15/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.5187 - accuracy: 0.7461 - val_loss: 0.4110 - val_accuracy: 0.7959\n",
      "Epoch 16/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4351 - accuracy: 0.7772 - val_loss: 0.3188 - val_accuracy: 0.8776\n",
      "Epoch 17/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4072 - accuracy: 0.7979 - val_loss: 0.7014 - val_accuracy: 0.6122\n",
      "Epoch 18/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.6399 - accuracy: 0.6528 - val_loss: 0.3580 - val_accuracy: 0.7959\n",
      "Epoch 19/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.6151 - accuracy: 0.6788 - val_loss: 0.5508 - val_accuracy: 0.7551\n",
      "Epoch 20/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.6014 - accuracy: 0.7824 - val_loss: 0.7927 - val_accuracy: 0.6327\n",
      "Epoch 21/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.6057 - accuracy: 0.7461 - val_loss: 0.3545 - val_accuracy: 0.8367\n",
      "Epoch 22/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.5995 - accuracy: 0.7461 - val_loss: 0.4451 - val_accuracy: 0.7755\n",
      "Epoch 23/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.6724 - accuracy: 0.7461 - val_loss: 0.9457 - val_accuracy: 0.5714\n",
      "Epoch 24/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.8102 - accuracy: 0.6114 - val_loss: 0.3960 - val_accuracy: 0.8163\n",
      "Epoch 25/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.6388 - accuracy: 0.7720 - val_loss: 0.3012 - val_accuracy: 0.8571\n",
      "Epoch 26/100\n",
      "7/7 [==============================] - 0s 44ms/step - loss: 0.4745 - accuracy: 0.7979 - val_loss: 0.3281 - val_accuracy: 0.8163\n",
      "Epoch 27/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4129 - accuracy: 0.8238 - val_loss: 0.2976 - val_accuracy: 0.8571\n",
      "Epoch 28/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3809 - accuracy: 0.8342 - val_loss: 0.2889 - val_accuracy: 0.8367\n",
      "Epoch 29/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3797 - accuracy: 0.8238 - val_loss: 0.6418 - val_accuracy: 0.6735\n",
      "Epoch 30/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.8321 - accuracy: 0.6373 - val_loss: 0.8086 - val_accuracy: 0.7551\n",
      "Epoch 31/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.7858 - accuracy: 0.7720 - val_loss: 0.6868 - val_accuracy: 0.6531\n",
      "Epoch 32/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.5676 - accuracy: 0.7565 - val_loss: 0.3067 - val_accuracy: 0.8367\n",
      "Epoch 33/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.7333 - accuracy: 0.6891 - val_loss: 0.3283 - val_accuracy: 0.8163\n",
      "Epoch 34/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5698 - accuracy: 0.7824 - val_loss: 0.3153 - val_accuracy: 0.8367\n",
      "Epoch 35/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.4736 - accuracy: 0.8031 - val_loss: 0.5187 - val_accuracy: 0.7959\n",
      "Epoch 36/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 1.3414 - accuracy: 0.7150 - val_loss: 0.2790 - val_accuracy: 0.8367\n",
      "Epoch 37/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 1.4810 - accuracy: 0.4767 - val_loss: 0.5076 - val_accuracy: 0.7755\n",
      "Epoch 38/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 1.2869 - accuracy: 0.7150 - val_loss: 0.3337 - val_accuracy: 0.7959\n",
      "Epoch 39/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 1.0146 - accuracy: 0.5596 - val_loss: 0.3137 - val_accuracy: 0.8163\n",
      "Epoch 40/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.9725 - accuracy: 0.7202 - val_loss: 0.4498 - val_accuracy: 0.7551\n",
      "Epoch 41/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.5430 - accuracy: 0.7565 - val_loss: 0.2688 - val_accuracy: 0.8163\n",
      "Epoch 42/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.6374 - accuracy: 0.7461 - val_loss: 0.3064 - val_accuracy: 0.8571\n",
      "Epoch 43/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.7502 - accuracy: 0.6062 - val_loss: 0.3151 - val_accuracy: 0.7959\n",
      "Epoch 44/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.9650 - accuracy: 0.7202 - val_loss: 0.5780 - val_accuracy: 0.7551\n",
      "Epoch 45/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.5589 - accuracy: 0.7254 - val_loss: 0.4608 - val_accuracy: 0.8163\n",
      "Epoch 46/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5084 - accuracy: 0.7720 - val_loss: 0.3232 - val_accuracy: 0.7959\n",
      "Epoch 47/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.4185 - accuracy: 0.8083 - val_loss: 0.3897 - val_accuracy: 0.7959\n",
      "Epoch 48/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.4356 - accuracy: 0.8187 - val_loss: 0.2732 - val_accuracy: 0.8163\n",
      "Epoch 49/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3936 - accuracy: 0.8342 - val_loss: 0.2642 - val_accuracy: 0.8571\n",
      "Epoch 50/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3721 - accuracy: 0.8238 - val_loss: 0.2742 - val_accuracy: 0.8163\n",
      "Epoch 51/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.3724 - accuracy: 0.8342 - val_loss: 0.3011 - val_accuracy: 0.8571\n",
      "Epoch 52/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4092 - accuracy: 0.7979 - val_loss: 0.2632 - val_accuracy: 0.8163\n",
      "Epoch 53/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3680 - accuracy: 0.8290 - val_loss: 0.2762 - val_accuracy: 0.8163\n",
      "Epoch 54/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.4386 - accuracy: 0.7979 - val_loss: 0.2679 - val_accuracy: 0.7959\n",
      "Epoch 55/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3843 - accuracy: 0.8238 - val_loss: 0.2639 - val_accuracy: 0.8163\n",
      "Epoch 56/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3764 - accuracy: 0.8394 - val_loss: 0.2660 - val_accuracy: 0.8163\n",
      "Epoch 57/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3658 - accuracy: 0.8446 - val_loss: 0.2595 - val_accuracy: 0.8163\n",
      "Epoch 58/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.4064 - accuracy: 0.8031 - val_loss: 0.2756 - val_accuracy: 0.8163\n",
      "Epoch 59/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3705 - accuracy: 0.8342 - val_loss: 0.2693 - val_accuracy: 0.8163\n",
      "Epoch 60/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3650 - accuracy: 0.8342 - val_loss: 0.2717 - val_accuracy: 0.8163\n",
      "Epoch 61/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.3812 - accuracy: 0.8031 - val_loss: 0.2976 - val_accuracy: 0.7959\n",
      "Epoch 62/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4379 - accuracy: 0.7720 - val_loss: 0.2973 - val_accuracy: 0.7959\n",
      "Epoch 63/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3999 - accuracy: 0.7824 - val_loss: 0.2830 - val_accuracy: 0.8367\n",
      "Epoch 64/100\n",
      "7/7 [==============================] - 0s 57ms/step - loss: 0.3726 - accuracy: 0.8290 - val_loss: 0.2960 - val_accuracy: 0.7959\n",
      "Epoch 65/100\n",
      "7/7 [==============================] - 0s 58ms/step - loss: 0.4268 - accuracy: 0.7824 - val_loss: 0.2883 - val_accuracy: 0.8571\n",
      "Epoch 66/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3477 - accuracy: 0.8601 - val_loss: 0.3709 - val_accuracy: 0.7755\n",
      "Epoch 67/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.7493 - accuracy: 0.7254 - val_loss: 0.2933 - val_accuracy: 0.8163\n",
      "Epoch 68/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.9944 - accuracy: 0.5751 - val_loss: 0.3116 - val_accuracy: 0.8571\n",
      "Epoch 69/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.7653 - accuracy: 0.7306 - val_loss: 0.2910 - val_accuracy: 0.8163\n",
      "Epoch 70/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.6731 - accuracy: 0.6995 - val_loss: 0.3410 - val_accuracy: 0.8776\n",
      "Epoch 71/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5814 - accuracy: 0.7617 - val_loss: 0.4832 - val_accuracy: 0.7551\n",
      "Epoch 72/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.4929 - accuracy: 0.7927 - val_loss: 0.3046 - val_accuracy: 0.8776\n",
      "Epoch 73/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.4462 - accuracy: 0.7668 - val_loss: 0.2881 - val_accuracy: 0.8367\n",
      "Epoch 74/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3851 - accuracy: 0.8394 - val_loss: 0.2639 - val_accuracy: 0.7959\n",
      "Epoch 75/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5075 - accuracy: 0.7979 - val_loss: 0.3609 - val_accuracy: 0.7755\n",
      "Epoch 76/100\n",
      "7/7 [==============================] - 0s 57ms/step - loss: 0.4599 - accuracy: 0.7565 - val_loss: 0.3936 - val_accuracy: 0.7959\n",
      "Epoch 77/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.4148 - accuracy: 0.8187 - val_loss: 0.3239 - val_accuracy: 0.7959\n",
      "Epoch 78/100\n",
      "7/7 [==============================] - 0s 57ms/step - loss: 0.4405 - accuracy: 0.7772 - val_loss: 0.2770 - val_accuracy: 0.8163\n",
      "Epoch 79/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3465 - accuracy: 0.8549 - val_loss: 0.2951 - val_accuracy: 0.8367\n",
      "Epoch 80/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3660 - accuracy: 0.8290 - val_loss: 0.2705 - val_accuracy: 0.8163\n",
      "Epoch 81/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3853 - accuracy: 0.8187 - val_loss: 0.3365 - val_accuracy: 0.8776\n",
      "Epoch 82/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.4300 - accuracy: 0.7979 - val_loss: 0.2742 - val_accuracy: 0.7755\n",
      "Epoch 83/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.3489 - accuracy: 0.8653 - val_loss: 0.3677 - val_accuracy: 0.7959\n",
      "Epoch 84/100\n",
      "7/7 [==============================] - 0s 57ms/step - loss: 0.6761 - accuracy: 0.6684 - val_loss: 0.2885 - val_accuracy: 0.8163\n",
      "Epoch 85/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.4812 - accuracy: 0.7461 - val_loss: 0.3174 - val_accuracy: 0.8163\n",
      "Epoch 86/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4925 - accuracy: 0.7513 - val_loss: 0.2871 - val_accuracy: 0.7959\n",
      "Epoch 87/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5317 - accuracy: 0.7979 - val_loss: 0.3800 - val_accuracy: 0.7959\n",
      "Epoch 88/100\n",
      "7/7 [==============================] - 0s 44ms/step - loss: 0.4481 - accuracy: 0.7720 - val_loss: 0.3335 - val_accuracy: 0.8571\n",
      "Epoch 89/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4836 - accuracy: 0.7876 - val_loss: 0.3751 - val_accuracy: 0.7959\n",
      "Epoch 90/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4298 - accuracy: 0.7927 - val_loss: 0.4078 - val_accuracy: 0.8163\n",
      "Epoch 91/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3987 - accuracy: 0.8238 - val_loss: 0.3872 - val_accuracy: 0.7551\n",
      "Epoch 92/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4831 - accuracy: 0.7513 - val_loss: 0.2874 - val_accuracy: 0.8367\n",
      "Epoch 93/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.4355 - accuracy: 0.8187 - val_loss: 0.2981 - val_accuracy: 0.8367\n",
      "Epoch 94/100\n",
      "7/7 [==============================] - 0s 46ms/step - loss: 0.3641 - accuracy: 0.8394 - val_loss: 0.2862 - val_accuracy: 0.8367\n",
      "Epoch 95/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3740 - accuracy: 0.8187 - val_loss: 0.2772 - val_accuracy: 0.8367\n",
      "Epoch 96/100\n",
      "7/7 [==============================] - 0s 55ms/step - loss: 0.3477 - accuracy: 0.8549 - val_loss: 0.2714 - val_accuracy: 0.8163\n",
      "Epoch 97/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.3527 - accuracy: 0.8446 - val_loss: 0.2709 - val_accuracy: 0.8163\n",
      "Epoch 98/100\n",
      "7/7 [==============================] - 0s 45ms/step - loss: 0.3518 - accuracy: 0.8187 - val_loss: 0.3093 - val_accuracy: 0.8571\n",
      "Epoch 99/100\n",
      "7/7 [==============================] - 0s 56ms/step - loss: 0.5058 - accuracy: 0.7720 - val_loss: 0.2779 - val_accuracy: 0.8163\n",
      "Epoch 100/100\n",
      "7/7 [==============================] - 0s 57ms/step - loss: 0.7768 - accuracy: 0.7254 - val_loss: 0.5054 - val_accuracy: 0.7551\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f07282d0b70>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = tf.keras.Sequential([\n",
    "        feature_layer,\n",
    "        layers.Dense(128, activation='relu'),\n",
    "        layers.Dense(128, activation='relu'),\n",
    "        layers.Dense(1, activation='sigmoid')\n",
    "])\n",
    "\n",
    "model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "model.fit(train_ds,\n",
    "          validation_data=val_ds,\n",
    "          epochs=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GnFmMOW0Tcaa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 0s 6ms/step - loss: 0.5217 - accuracy: 0.7541\n",
      "Accuracy 0.75409836\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(test_ds)\n",
    "print(\"Accuracy\", accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Submission Instructions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now click the 'Submit Assignment' button above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# When you're done or would like to take a break, please run the two cells below to save your work and close the Notebook. This frees up resources for your fellow learners."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "<!-- Save the notebook -->\n",
    "IPython.notebook.save_checkpoint();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "<!-- Shutdown and close the notebook -->\n",
    "window.onbeforeunload = null\n",
    "window.close();\n",
    "IPython.notebook.session.delete();"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "qRLGSMDzM-dl"
   ],
   "name": "Week 2-Question.ipynb",
   "private_outputs": true,
   "provenance": [],
   "toc_visible": true
  },
  "coursera": {
   "course_slug": "data-pipelines-tensorflow",
   "graded_item_id": "rQvlJ",
   "launcher_item_id": "DXaub"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}