{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# CS-109A Introduction to Data Science\n",
"\n",
"\n",
"## Lecture 33 Notebook: Training a FFN \n",
"\n",
"**Harvard University** \n",
"**Fall 2020** \n",
"**Instructors:** Pavlos Protopapas, Kevin Rader, Chris Tanner \n",
"**Authors:** Eleni Kaxiras, David Sondak, and Pavlos Protopapas. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Title\n",
"\n",
"**Exercise 1**\n",
"\n",
"# Description\n",
"\n",
"For this exercise you will work on a notebook outside of Ed. Ways to run the notebook:\n",
"1. Download the notebook (using the >> in the Challenge) and image files to your local enviromnent. DO NOT RUN IN Ed.\n",
"2. Download from CS109a public git repository (easier for those who have cloned it): https://github.com/Harvard-IACS/2020-CS109A/blob/master/content/lectures/lecture33/notebook/Lec33_students.ipynb\n",
"3. Use Google Colab: \n",
" - Public Link to Google Colab Notebook for Lecture 33 : https://colab.research.google.com/drive/16MqFE1vIrX4OdOgV8A9GpMmIuBmlSAqR?usp=sharing)\n",
"\n",
" - Public Link to kanye_shoe.jpg, a photo of a very important shoe : https://github.com/Harvard-IACS/2020-CS109A/blob/master/content/lectures/lecture33/notebook/kanye_shoe.jpg"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### (student edition)"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n"
],
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## RUN THIS CELL TO PROPERLY HIGHLIGHT CELLS\n",
"import requests\n",
"from IPython.core.display import HTML\n",
"styles = requests.get(\"https://raw.githubusercontent.com/Harvard-IACS/2018-CS109A/master/content/styles/cs109.css\").text\n",
"HTML(styles)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Using TensorFlow backend.\n"
]
}
],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import matplotlib.image as mpimg\n",
"import numpy as np\n",
"import pandas as pd\n",
"from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
"from sklearn.preprocessing import StandardScaler\n",
"%matplotlib inline\n",
"\n",
"from PIL import Image, ImageOps"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.0.0\n"
]
}
],
"source": [
"from __future__ import absolute_import, division, print_function, unicode_literals\n",
"\n",
"# TensorFlow and tf.keras\n",
"import tensorflow as tf\n",
"\n",
"tf.keras.backend.clear_session() # For easy reset of notebook state.\n",
"\n",
"print(tf.__version__) # You should see a 2.0.0 here!"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"# set the seed for reproducability\n",
"seed = 7\n",
"np.random.seed(seed)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tensorflow 2.0: \n",
"\n",
"All references to Keras should be written as `tf.keras`. For example: \n",
"\n",
"```\n",
"model = tf.keras.models.Sequential([\n",
" tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
" tf.keras.layers.Dense(128, activation='relu'),\n",
" tf.keras.layers.Dropout(0.2),\n",
" tf.keras.layers.Dense(10, activation='softmax')\n",
"])\n",
"\n",
"model.compile(optimizer='adam',\n",
" loss='sparse_categorical_crossentropy',\n",
" metrics=['accuracy'])\n",
" \n",
"tf.keras.models.Sequential\n",
"tf.keras.layers.Dense, tf.keras.layers.Activation, \n",
"tf.keras.layers.Dropout, tf.keras.layers.Flatten, tf.keras.layers.Reshape\n",
"tf.keras.optimizers.SGD\n",
"tf.keras.preprocessing.image.ImageDataGenerator\n",
"tf.keras.regularizers\n",
"tf.keras.datasets.mnist \n",
"```\n",
"\n",
"You could avoid the long names by using\n",
"```\n",
"from tensorflow import keras\n",
"from tensorflow.keras import layers\n",
"```\n",
"These imports do not work on some systems, however, because they pick up previous versions of `keras` and `tensorflow`. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tensors\n",
"\n",
"We can think of tensors as multidimensional arrays of real numerical values; their job is to generalize matrices to multiple dimensions. \n",
"\n",
"- **scalar** = just a number = rank 0 tensor ($a$ ∈ $F$,)\n",
"
\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### First you build the network\n",
"\n",
"- **The input layer**: our dataset.\n",
"- **The internal architecture or hidden layers** the number of layers, the activation functions, the learnable parameters and other hyperparameters)\n",
"- **The output layer**: what we want from the network, a probability for belonging in a class (classification) or a number (regression).\n",
"\n",
"1. Load and pre-process the data\n",
"2. Define the layers of the model.\n",
"3. Compile the model.\n",
"\n",
"### ... and then you train it!\n",
"\n",
"4. Fit the model to the train set (also using a validation set). Save the model.\n",
"5. Evaluate the model on the test set.\n",
"6. We learn a lot by studying history: metric traceplots. \n",
"7. Regularize the model.\n",
"8. Now let's use the Network to predict on the test set.\n",
"9. Try our model on a sandal from the Kanye West collection!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1. Load the data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fashion MNIST \n",
"\n",
"**Fashion-MNIST** is a dataset of clothing article images (created by [Zalando](https://github.com/zalandoresearch/fashion-mnist)), consisting of a training set of 60,000 examples and a test set of 10,000 examples. Each example is a **28 x 28** grayscale image, associated with a label from **10 classes**. The creators intend Fashion-MNIST to serve as a direct drop-in replacement for the original MNIST dataset for benchmarking machine learning algorithms. It shares the same image size and structure of training and testing splits. Each pixel is 8 bits so its value ranges from 0 to 255. These images do not have a `channel` dimension because they are B&W.\n",
"\n",
"Let's load and look at it!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# get the data from keras\n",
"fashion_mnist = tf.keras.datasets.fashion_mnist\n",
"\n",
"# load the data splitted in train and test! \n",
"(x_train, y_train),(x_test, y_test) = fashion_mnist.load_data()\n",
"\n",
"print(x_train.shape, y_train.shape, '\\n\\n', x_train[56][:2], '\\n\\n', set(y_train))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# checking the min and max of x_train and x_test\n",
"print(x_train.min(), x_train.max(), x_test.min(), x_test.max())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# normalize the data by dividing with pixel intensity\n",
"# (each pixel is 8 bits so its value ranges from 0 to 255)\n",
"x_train, x_test = x_train / 255.0, x_test / 255.0\n",
"\n",
"print(x_train.min(), x_train.max(), x_test.min(), x_test.max())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# inspect a single image array\n",
"print(x_train[45].shape)\n",
"print(x_train[45][:2][:2])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Give names to classes for clarity\n",
"class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
" 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
"\n",
"# plot\n",
"plt.figure(figsize=(10,10))\n",
"for i in range(25):\n",
" plt.subplot(5,5,i+1)\n",
" plt.xticks([])\n",
" plt.yticks([])\n",
" plt.grid(False)\n",
" plt.imshow(x_train[i], cmap=plt.cm.binary)\n",
" plt.xlabel(class_names[y_train[i]])\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. Define the layers of the model."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"model = tf.keras.Sequential()\n",
"model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))\n",
"model.add(tf.keras.layers.Dense(154, activation='relu'))\n",
"model.add(tf.keras.layers.Dense(154, activation='relu'))\n",
"model.add(tf.keras.layers.Dense(154, activation='relu'))\n",
"model.add(tf.keras.layers.Dense(64, activation='relu'))\n",
"model.add(tf.keras.layers.Dense(10, activation='softmax'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3. Compile the model"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()\n",
"optimizer = tf.keras.optimizers.Adam()\n",
"\n",
"model.compile(optimizer=optimizer,\n",
" loss=loss_fn,\n",
" metrics=['accuracy'])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"tf.keras.utils.plot_model(\n",
" model,\n",
" #to_file='model.png', # if you want to save the image\n",
" show_shapes=True, # True to see more details \n",
" show_layer_names=True,\n",
" rankdir='TB',\n",
" expand_nested=True,\n",
" dpi=150\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Everything you wanted to know about a Keras Model and were afraid to ask](https://www.tensorflow.org/api_docs/python/tf/keras/Model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4. Fit the model to the train set (also using a validation set)\n",
"\n",
"This is the part that takes the longest.\n",
"\n",
"-----------------------------------------------------------\n",
"**ep·och** \n",
"noun: epoch; plural noun: epochs. A period of time in history or a person's life, typically one marked by notable events or particular characteristics. Examples: \"the Victorian epoch\", \"my Neural Netwok's epochs\". \n",
" \n",
"-----------------------------------------------------------"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%%time\n",
"# Fit the model <--- always a good idea to time it! \n",
"\n",
"history = model.fit(x_train, y_train, validation_split=0.33, epochs=50, \n",
" verbose=2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Save the model\n",
"\n",
"You can save the model so you do not have `.fit` everytime you reset the kernel in the notebook. Network training is expensive!\n",
"\n",
"For more details on this see [https://www.tensorflow.org/guide/keras/save_and_serialize](https://www.tensorflow.org/guide/keras/save_and_serialize)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# save the model so you do not have to run the code everytime\n",
"model.save('fashion_model.h5')\n",
"\n",
"# Recreate the exact same model purely from the file\n",
"#model = tf.keras.models.load_model('fashion_model.h5')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5. Evaluate the model on the test set."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)\n",
"print(f'Test accuracy={test_accuracy}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 6. We learn a lot by studying history: metric traceplots. \n",
"\n",
"You can learn a lot about neural networks by observing how they perform while training. The networks's performance is stored in a variable named `history` which can be plotted. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(history.history.keys())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# plot accuracy and loss for the test set\n",
"fig, ax = plt.subplots(1,2, figsize=(20,6))\n",
"\n",
"ax[0].plot(history.history['accuracy'])\n",
"ax[0].plot(history.history['val_accuracy'])\n",
"ax[0].set_title('Model accuracy')\n",
"ax[0].set_ylabel('accuracy')\n",
"ax[0].set_xlabel('epoch')\n",
"ax[0].legend(['train', 'val'], loc='best')\n",
"\n",
"ax[1].plot(history.history['loss'])\n",
"ax[1].plot(history.history['val_loss'])\n",
"ax[1].set_title('Model loss')\n",
"ax[1].set_ylabel('loss')\n",
"ax[1].set_xlabel('epoch')\n",
"ax[1].legend(['train', 'val'], loc='best')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
What do you observe in these traceplots?
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Breakout Room Activity"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 7. Regularization\n",
"Let's try adding a regularizer in our model. Name your new model `model_regular`. For more see `tf.keras` [regularizers](https://www.tensorflow.org/api_docs/python/tf/keras/regularizers). \n",
"\n",
"1. Norm penalties: \n",
" ```\n",
" model_regular.add(tf.keras.layers.Dense(154, activation='relu', \n",
" kernel_regularizer= tf.keras.regularizers.l2(l=0.001)))\n",
" ```\n",
"2. Early stopping via `tf.keras.callbacks`. Callbacks provide a way to interact with the model while it's training and inforce some decisions automatically. Callbacks need to be instantiated and are added to the `.fit()` function via the `callbacks` argument.\n",
" ```\n",
" # callbacks: watch validation loss and be \"patient\" for 10 epochs of no improvement\n",
" es = tf.keras.callbacks.EarlyStopping(monitor='val_loss', verbose=1, patience=20) \n",
" model_regular.fit(x_train, y_train, validation_split=0.2, epochs=50, \n",
" verbose=1, callbacks=[es])\n",
" ```\n",
"3. Dropout\n",
" ```\n",
" model_regular.add(tf.keras.layers.Dropout(0.2))\n",
" ```\n",
"4. Remove layers"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Note: Name your new model `model_regular` for the rest of the code to work."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# your code here\n",
"# define the model\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# compile the model\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# fit the model\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# evaluate on test set\n",
"test_loss_regular, test_accuracy_regular = model_regular.evaluate(x_test, y_test, verbose=0)\n",
"print(f'Test accuracy:\\nBaseline model={test_accuracy:.4f}\\nRegularized model={test_accuracy_regular:.4f}')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# plot accuracy and loss for the test set\n",
"fig, ax = plt.subplots(1,2, figsize=(20,6))\n",
"\n",
"ax[0].plot(history_regular.history['accuracy'])\n",
"ax[0].plot(history_regular.history['val_accuracy'])\n",
"ax[0].set_title('Model accuracy')\n",
"ax[0].set_ylabel('accuracy')\n",
"ax[0].set_xlabel('epoch')\n",
"ax[0].legend(['train', 'val'], loc='best')\n",
"\n",
"ax[1].plot(history_regular.history['loss'])\n",
"ax[1].plot(history_regular.history['val_loss'])\n",
"ax[1].set_title('Model loss')\n",
"ax[1].set_ylabel('loss')\n",
"ax[1].set_xlabel('epoch')\n",
"ax[1].legend(['train', 'val'], loc='best')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
In class discussion : How far did you get with regularization?
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 7. Now let's predict in the test set"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"predictions = model_regular.predict(x_test)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# choose a specific item to predict (one out of the 60000 samples)\n",
"item = 6"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"predictions[item]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.argmax(predictions[item]), class_names[np.argmax(predictions[item])]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's see if our network predicted right! Is the first item what was predicted?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.figure()\n",
"plt.imshow(x_test[item], cmap=plt.cm.binary)\n",
"plt.xlabel(class_names[y_test[item]])\n",
"plt.colorbar()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# code source: https://www.tensorflow.org/tutorials/keras/classification\n",
"def plot_image(i, predictions_array, true_label, img):\n",
" predictions_array, true_label, img = predictions_array, true_label[i], img[i]\n",
" plt.grid(False)\n",
" plt.xticks([])\n",
" plt.yticks([])\n",
"\n",
" plt.imshow(img, cmap=plt.cm.binary)\n",
"\n",
" predicted_label = np.argmax(predictions_array)\n",
" if predicted_label == true_label:\n",
" color = 'blue'\n",
" else:\n",
" color = 'red'\n",
"\n",
" plt.xlabel(\"{} {:2.0f}% ({})\".format(class_names[predicted_label],\n",
" 100*np.max(predictions_array),\n",
" class_names[true_label]),\n",
" color=color)\n",
"\n",
"def plot_value_array(i, predictions_array, true_label):\n",
" predictions_array, true_label = predictions_array, true_label[i]\n",
" plt.grid(False)\n",
" plt.xticks(range(10))\n",
" plt.yticks([])\n",
" thisplot = plt.bar(range(10), predictions_array, color=\"#777777\")\n",
" plt.ylim([0, 1])\n",
" predicted_label = np.argmax(predictions_array)\n",
"\n",
" thisplot[predicted_label].set_color('red')\n",
" thisplot[true_label].set_color('blue')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"i = item\n",
"plt.figure(figsize=(6,3))\n",
"plt.subplot(1,2,1)\n",
"plot_image(i, predictions[i], y_test, x_test)\n",
"plt.subplot(1,2,2)\n",
"plot_value_array(i, predictions[i], y_test)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 8. Try our model on a sandal from the Kanye West collection!\n",
"The true usefullness of a NN is to be able to classigy unseen data and not only on the test set. Let's see if our network can generalize beyond the MNIST fashion dataset. Let's give it a trendy shoe and see what it predicts. This image is not part of the test set, it was downloaded from the internet. \n",
"\n",
" \n",
"
In class discussion : What kinds of images can our model predict?
\n",
"\n",
"Bias measures how much the network's output, averaged over all possible data sets differs from the true function. Variance measures how much the network output varies between datasets. Is generalization the pillar of Intelligence?"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"