diff --git a/assignment1/assignment1.ipynb b/assignment1/assignment1.ipynb new file mode 100644 index 0000000..7abd75c --- /dev/null +++ b/assignment1/assignment1.ipynb @@ -0,0 +1,884 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# import pandas for csv data loading\n", + "import pandas as pd\n", + "import numpy as np\n", + "import sklearn\n", + "import sklearn.preprocessing as pre" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 1 Linear regression\n", + "\n", + "We are gonna use the Computer Hardware Data Set for this task, https://archive.ics.uci.edu/ml/datasets/Computer+Hardware\n", + "\n", + "![](pics/cpu.jpg)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
vendornameMYCTMMINMMAXCACHCHMINCHMAXPRPERP
0adviser32/60125256600025616128198199
1amdahl470v/72980003200032832269253
2amdahl470v/7a2980003200032832220253
3amdahl470v/7b2980003200032832172253
4amdahl470v/7c2980001600032816132132
\n", + "
" + ], + "text/plain": [ + " vendor name MYCT MMIN MMAX CACH CHMIN CHMAX PRP ERP\n", + "0 adviser 32/60 125 256 6000 256 16 128 198 199\n", + "1 amdahl 470v/7 29 8000 32000 32 8 32 269 253\n", + "2 amdahl 470v/7a 29 8000 32000 32 8 32 220 253\n", + "3 amdahl 470v/7b 29 8000 32000 32 8 32 172 253\n", + "4 amdahl 470v/7c 29 8000 16000 32 8 16 132 132" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.read_csv('data/cpu_performance/machine.data').head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This dataset has 10 attribute:\n", + "\n", + "- vendor: is the name of the vender\n", + "- name: many unique symbols\n", + "- MYCT: machine cycle time in nanoseconds (integer)\n", + "- MMIN: minimum main memory in kilobytes (integer)\n", + "- MMAX: maximum main memory in kilobytes (integer)\n", + "- CACH: cache memory in kilobytes (integer)\n", + "- CHMIN: minimum channels in units (integer)\n", + "- CHMAX: maximum channels in units (integer)\n", + "- PRP: published relative performance (integer)\n", + "- ERP: estimated relative performance from the original article (integer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The task is to use the first 8 attribute to predict the 9th attribute (which is the published relative performance)\n", + "\n", + "You will need to build a linear regression model for this task, by using MSE(mean square error) loss function, you are expected to get a loss lower than 6000 on you test set" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def Linear_regress (x_train, y_train,iters = 10000, step = 0.001):\n", + " theta = np.zeros(x_train.shape[1])\n", + " for i in range(iters):\n", + " h = np.dot(x_train, theta)\n", + " gradient = np.dot(h - y_train, x_train)/y_train.size\n", + " theta = theta - step * gradient\n", + " return theta" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv('data/cpu_performance/machine.data')\n", + "x1, x2, y = np.array(df.iloc[:,0:2]),np.array(df.iloc[:,2:-2]), np.array(df.iloc[:,-2])\n", + "enc = pre.OneHotEncoder()\n", + "x1 = enc.fit_transform(x1).toarray()\n", + "x2_mean, y_mean = np.mean(x2,axis = 0), np.mean(y,axis = 0)\n", + "x2_std, y_std = np.std(x2,axis = 0), np.std(y,axis = 0)\n", + "x2,y = (x2 - x2_mean) / x2_std, (y - y_mean) / y_std\n", + "x = np.concatenate((x1, x2), axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 60)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# add constant column\n", + "x_train = np.concatenate((np.ones((x_train.shape[0], 1)), x_train), axis=1)\n", + "x_test = np.concatenate((np.ones((x_test.shape[0], 1)), x_test), axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1593.9033341468166" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "theta = Linear_regress(x_train,y_train)\n", + "h_test = np.dot(x_test, theta)\n", + "h_test_t = h_test * y_std + y_mean\n", + "y_test_t = y_test * y_std + y_mean\n", + "cost = ((h_test_t - y_test_t) ** 2 / 2).mean()\n", + "cost" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Linear regression using sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "model = LinearRegression()\n", + "model.fit(x_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1948.8204269476373" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h_test = model.predict(x_test)\n", + "h_test_t = h_test * y_std + y_mean\n", + "y_test_t = y_test * y_std + y_mean\n", + "cost = ((h_test_t - y_test_t) ** 2 / 2).mean()\n", + "cost" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 2 Logistic regression\n", + "\n", + "\n", + "The dataset we are gonna use is Glass identification dataset from UCI Machine Learning repository https://archive.ics.uci.edu/ml/datasets/Glass+Identification\n", + "![](pics/glass.jpg)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idRINaMgAlSiKCaBaFeclass
011.5210113.644.491.1071.780.068.750.00.01
121.5176113.893.601.3672.730.487.830.00.01
231.5161813.533.551.5472.990.397.780.00.01
341.5176613.213.691.2972.610.578.220.00.01
451.5174213.273.621.2473.080.558.070.00.01
\n", + "
" + ], + "text/plain": [ + " id RI Na Mg Al Si K Ca Ba Fe class\n", + "0 1 1.52101 13.64 4.49 1.10 71.78 0.06 8.75 0.0 0.0 1\n", + "1 2 1.51761 13.89 3.60 1.36 72.73 0.48 7.83 0.0 0.0 1\n", + "2 3 1.51618 13.53 3.55 1.54 72.99 0.39 7.78 0.0 0.0 1\n", + "3 4 1.51766 13.21 3.69 1.29 72.61 0.57 8.22 0.0 0.0 1\n", + "4 5 1.51742 13.27 3.62 1.24 73.08 0.55 8.07 0.0 0.0 1" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.read_csv('data/glass_ident/glass.data').head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This dataset has 10 attributes:\n", + "\n", + "- id is a number representing the specific data point\n", + "- RI is the refractive index\n", + "- Na: Sodium (unit measurement: weight percent in corresponding oxide, as are attributes 4-10)\n", + "- Mg: Magnesium\n", + "- Al: Aluminum\n", + "- Si: Silicon\n", + "- K: Potassium\n", + "- Ca: Calcium\n", + "- Ba: Barium\n", + "- Fe: Iron" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This dataset has 6 class, which is 1,2,3,5,6,7, NOTE THAT IN THIS DATASET THERE IS NO CLASS 4\n", + "\n", + "- 1 building_windows_float_processed\n", + "- 2 building_windows_non_float_processed\n", + "- 3 vehicle_windows_float_processed\n", + "- 4 vehicle_windows_non_float_processed (None in this dataset)\n", + "- 5 containers\n", + "- 6 tableware\n", + "- 7 headlamps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You have two sub-tasks on this dataset;\n", + "\n", + "1. Build a logistic regression model to classify class 2 and not class 2, i.e. a binary classifier to separate class 2 from everything else. This binary classifier should be able to get an accuracy higher than 85%\n", + "2. Build a multiclass classification model by build 6 binary classifiers. This multiclass classifier should be able to get an accuracy higher than 50%" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Grading Policy\n", + "\n", + "You can use some high level library(PyTorch, TensorFlow, sklearn) to complete the tasks, But there will be **Bonus** if you use **Numpy** to implement the algorithms from scratch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward pass, compute classifier output and cross entropy loss\n", + "\n", + "compute $h_{\\theta}(x)$\n", + "$$\n", + "h_{\\theta}(x)=\\frac{1}{1+e^{-\\theta^T x}}\n", + "$$\n", + "\n", + "compute $J(\\theta)$\n", + "\n", + "$$\n", + "J(\\theta)=\\frac{1}{m}\\sum_{i=1}^{m}Cost(h_{\\theta}(x^{(i)}),y^{(i)})\n", + "$$\n", + "\n", + "compute $Cost(h_{\\theta}, y)$ (cross entropy)\n", + "\n", + "$$\n", + "Cost(h_{\\theta}, y)=-y log((h_{\\theta}(x))-(1-y)log(1-(h_{\\theta}(x)))\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Backward pass, compute gradients and update the classifier's weight\n", + "\n", + "compute the gradient\n", + "$$\n", + "\\frac{\\partial J(\\theta)}{\\partial \\theta}=\\sum_{i=1}^{m}(h_{\\theta}(x)-y^{(i)})x^{(i)}\n", + "$$\n", + "\n", + "update the weights\n", + "$$\n", + "\\theta_{j}^{new}=\\theta_{j}^{old}-\\alpha\\frac{\\partial J(\\theta)}{\\partial \\theta}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def binary_class(x_train, y_train,iters = 1000, step = 0.01):\n", + " theta = np.zeros(x_train.shape[1])\n", + " for i in range(iters):\n", + " # forward\n", + " h = 1 / (1 + np.exp(-np.dot(x_train, theta)))\n", + " cost = (-y_train * np.log(h)-(1 - y_train) * np.log(1 - h)).mean()\n", + " # backward\n", + " gradient = np.dot(h - y_train, x_train)/y_train.size\n", + " theta = theta - step * gradient\n", + " # display\n", + " #if i % 50 == 0:\n", + " #print('Iters', i, 'cost:', cost) \n", + " return theta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Binary classification " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv('data/glass_ident/glass.data')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "x, y = np.array(df.iloc[:,1:-1]), np.array(df.iloc[:,-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "y[y != 3] = 0\n", + "y[y == 3] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 60)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "x_train_mean,x_train_std = np.mean(x_train,axis = 0),np.std(x_train,axis = 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "x_train = (x_train - x_train_mean) / x_train_std\n", + "x_test = (x_test - x_train_mean) / x_train_std\n", + "# add constant column\n", + "x_train = np.concatenate((np.ones((x_train.shape[0], 1)), x_train), axis=1)\n", + "x_test = np.concatenate((np.ones((x_test.shape[0], 1)), x_test), axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "theta1 = binary_class(x_train, y_train, 1000, 0.05)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9384615384615385" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h_test = 1 / (1 + np.exp(-np.dot(x_test, theta1)))\n", + "((h_test > 0.5) == y_test).sum() / y_test.size" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Binary classification using sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "binary_model = LogisticRegression(random_state=0, solver='lbfgs')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9230769230769231" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# train\n", + "binary_model.fit(x_train,y_train) \n", + "# predict\n", + "h_test = binary_model.predict_proba(x_test)\n", + "h_test = h_test[:, 1]\n", + "((h_test > 0.5) == y_test).sum() / y_test.size\n", + "#print(binary_model.score(x_test,y_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multi-class classification" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def multi_class(x_train, y_train):\n", + " num_class = list(range(1,8))\n", + " param = np.zeros((len(num_class), x_train.shape[1]))\n", + " \n", + " for i,line in enumerate(num_class):\n", + " label_t = np.zeros_like(y_train)\n", + " label_t[y_train == line] = 1\n", + " param[i, :] = binary_class(x_train, label_t,10000,0.0001)\n", + " \n", + " return param" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv('data/glass_ident/glass.data')\n", + "x, y = np.array(df.iloc[:,1:-1]), np.array(df.iloc[:,-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 60)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "x_train_mean,x_train_std = np.mean(x_train,axis = 0),np.std(x_train,axis = 0)\n", + "\n", + "x_train = (x_train - x_train_mean) / x_train_std\n", + "x_test = (x_test - x_train_mean) / x_train_std\n", + "\n", + "x_train = np.concatenate((np.ones((x_train.shape[0], 1)), x_train), axis=1)\n", + "x_test = np.concatenate((np.ones((x_test.shape[0], 1)), x_test), axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "params = multi_class(x_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def multi_pred(param, x_test, y_test):\n", + " logits = np.dot(x_test, np.transpose(param)).squeeze()\n", + " prob = 1 / (1 + np.exp(-logits))\n", + " pred = np.argmax(prob, axis=1) + 1\n", + " accuracy = np.sum(pred == y_test) / y_test.shape[0] * 100\n", + " return prob, pred, accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction: [1 1 2 2 1 7 2 1 1 1 1 2 1 5 1 7 7 2 1 7 2 1 7 2 1 2 2 1 1 1 2 1 1 7 7 1 2\n", + " 7 1 1 2 1 2 7 2 7 1 7 1 1 1 2 2 5 1 1 2 7 1 1 1 2 1 7 7]\n", + "\n", + "Accuracy: 64.615%\n" + ] + } + ], + "source": [ + "_, preds, accu = multi_pred(params, x_test, y_test)\n", + "print(\"Prediction: {}\\n\".format(preds))\n", + "print(\"Accuracy: {:.3f}%\".format(accu))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multi-class classification using sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "multi_model = LogisticRegression(random_state=0, solver='lbfgs', multi_class='multinomial').fit(x_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "proba = multi_model.predict_proba(x_test)\n", + "preds = np.argmax(proba, axis=1)+1\n", + "preds[preds > 3] = preds[preds > 3]+1\n", + "accu = np.sum(preds == y_test) / y_test.shape[0] * 100" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction: [1 2 2 2 1 7 2 1 1 1 2 2 1 2 1 7 7 2 1 7 1 1 7 1 1 1 2 1 2 2 2 2 1 7 2 1 2\n", + " 7 2 1 1 1 3 7 2 7 2 6 1 1 2 2 2 5 1 1 2 7 1 1 2 2 1 2 7]\n", + "\n", + "Accuracy: 63.077%\n" + ] + } + ], + "source": [ + "print(\"Prediction: {}\\n\".format(preds))\n", + "print(\"Accuracy: {:.3f}%\".format(accu))" + ] + } + ], + "metadata": { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/assignment1/pics/cpu.jpg b/assignment1/pics/cpu.jpg new file mode 100644 index 0000000..b2b983b Binary files /dev/null and b/assignment1/pics/cpu.jpg differ diff --git a/assignment1/pics/glass.jpg b/assignment1/pics/glass.jpg new file mode 100644 index 0000000..5dab979 Binary files /dev/null and b/assignment1/pics/glass.jpg differ diff --git a/assignment1/pics/iris.jpg b/assignment1/pics/iris.jpg new file mode 100644 index 0000000..85bb9b4 Binary files /dev/null and b/assignment1/pics/iris.jpg differ diff --git a/assignment1/pics/logistic_regression.jpg b/assignment1/pics/logistic_regression.jpg new file mode 100644 index 0000000..88a0671 Binary files /dev/null and b/assignment1/pics/logistic_regression.jpg differ diff --git a/assignment1/pics/train.gif b/assignment1/pics/train.gif new file mode 100644 index 0000000..fb04b22 Binary files /dev/null and b/assignment1/pics/train.gif differ diff --git a/assignment2/assignment2.ipynb b/assignment2/assignment2.ipynb new file mode 100644 index 0000000..55f87a3 --- /dev/null +++ b/assignment2/assignment2.ipynb @@ -0,0 +1,438 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MNIST hand-written digit classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](pics/mnist.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Digit range from 0~9, training set consist of 60000 images, and test set consist of 10000 images." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task 1: One layer SoftMax Classifier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Forward Pass of SoftMax Classifier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](pics/formula1.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "import os\n", + "import glob\n", + "import random\n", + "import numpy as np\n", + "from PIL import Image\n", + "from tqdm import tqdm_notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def load_data(train_path='/train', test_path='test/'):\n", + " train_list = glob.glob(os.path.join(train_path, '*.png'))\n", + " pattern = re.compile(r'num(\\d).png')\n", + " train_id = np.array([float(pattern.search(img_name).groups()[0]) for img_name in train_list])\n", + " train_data = np.concatenate([np.array(Image.open(img_name)).reshape((1, 784))for img_name in tqdm_notebook(train_list, leave=False)],\n", + " axis=0).astype(np.float)\n", + "\n", + " test_list = glob.glob(os.path.join(test_path, '*.png'))\n", + " test_id = np.array([float(pattern.search(img_name).groups()[0]) for img_name in test_list])\n", + " test_data = np.concatenate([np.array(Image.open(img_name)).reshape((1, 784)) for img_name in tqdm_notebook(test_list, leave=False)],\n", + " axis=0).astype(np.float)\n", + "\n", + " return train_data, train_id, test_data, test_id" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "train_path = r'C:\\Users\\GS65\\Desktop\\assignment2\\train' \n", + "test_path = r'C:\\Users\\GS65\\Desktop\\assignment2\\test'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=60000), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=10000), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r" + ] + } + ], + "source": [ + "train_data, train_id, test_data, test_id = load_data(train_path,test_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def softmax(scores):\n", + " exp_scores = np.nan_to_num(np.exp(scores))\n", + " probs = exp_scores / np.sum(exp_scores, axis=1, keepdims = True)\n", + " probs = np.nan_to_num(probs)\n", + " return probs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def loss_compute(probs, labels, reg=0, W=0):\n", + " L = probs[range(probs.shape[0]),labels.astype('int64')]\n", + " L = np.nan_to_num(-np.log(L))\n", + " data_loss = np.sum(L)/L.shape[0]\n", + " if reg:\n", + " reg_loss = 0.5 * reg * np.sum(W * W)\n", + " return (data_loss + reg_loss)\n", + " else:\n", + " return data_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def One_layer_classifier(x_train, y_train, epochs, mini_batch_size, step, reg=0):\n", + " np.random.seed(42)\n", + " w = 0.01 * np.random.randn(x_train.shape[1],10)\n", + " b = np.zeros((1,10))\n", + " training = [(x,y) for x,y in zip(x_train,y_train)]\n", + " n = len(x_train)\n", + " for i in range(epochs):\n", + " random.shuffle(training)\n", + " mini_batches = [training[k:k+mini_batch_size]\n", + " for k in range(0, n, mini_batch_size)]\n", + " \n", + " for mini_batch in mini_batches:\n", + " # forward\n", + " x_batch = np.concatenate([np.array(t[0]).reshape((1, 784)) for t in mini_batch])\n", + " y_batch = np.array([t[1] for t in mini_batch])\n", + " scores = np.dot(x_batch, w) + b\n", + " probs = softmax(scores)\n", + " # backward\n", + " dscores = probs\n", + " dscores[range(x_batch.shape[0]),y_batch.astype('int64')] -= 1\n", + " dscores = dscores/x_batch.shape[0]\n", + " dw = np.dot(x_batch.T, dscores)\n", + " dw += reg * w\n", + " db = np.sum(dscores, axis=0, keepdims=True)\n", + " w += -step * dw/len(mini_batch)\n", + " b += -step * db/len(mini_batch)\n", + "\n", + "\n", + " # compute loss \n", + " if i % 100 ==0:\n", + " t_scores = np.dot(x_train, w) + b\n", + " t_probs = softmax(t_scores)\n", + " loss = loss_compute(t_probs,y_train,reg,w)\n", + " print (\"iteration %d: loss %f\" % (i, loss)) \n", + " return w,b" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def accuracy(w, b, x_test, y_test):\n", + " scores = np.dot(x_test,w) + b\n", + " predict = np.argmax(scores, axis=1)\n", + " print('training accuracy: %.2f' % (np.mean(predict == y_test))) " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0: loss 1.291193\n", + "iteration 100: loss 0.481483\n", + "iteration 200: loss 0.458341\n", + "iteration 300: loss 0.361681\n", + "iteration 400: loss 0.545539\n", + "iteration 500: loss 0.387182\n", + "iteration 600: loss 0.450068\n", + "iteration 700: loss 0.361206\n", + "iteration 800: loss 0.406088\n", + "iteration 900: loss 0.516441\n", + "training accuracy: 0.89\n" + ] + } + ], + "source": [ + "w, b = One_layer_classifier(train_data, train_id, 1000, 100, 0.005, reg=0)\n", + "accuracy(w, b, test_data, test_id) " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0: loss 1.312432\n", + "iteration 100: loss 0.577875\n", + "iteration 200: loss 0.490529\n", + "iteration 300: loss 0.400090\n", + "iteration 400: loss 0.602941\n", + "iteration 500: loss 0.476072\n", + "iteration 600: loss 0.523681\n", + "iteration 700: loss 0.440059\n", + "iteration 800: loss 0.528997\n", + "iteration 900: loss 0.397138\n", + "training accuracy: 0.83\n" + ] + } + ], + "source": [ + "w, b = One_layer_classifier(train_data, train_id, 1000, 100, 0.005, reg=0.5)\n", + "accuracy(w, b, test_data, test_id) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task 2: Two Layer neural network" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Forward Pass of a Two layer neural network" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](pics/formula2.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "class Network:\n", + "\n", + " def __init__(self,sizes):\n", + " self.sizes = sizes\n", + " self.b = [0.01 * np.random.randn(1, y) for y in sizes[1:]]\n", + " self.w = [0.01 * np.random.randn(x, y) for x, y in zip(sizes[:-1], sizes[1:])]\n", + "\n", + " def loss_compute(self, x_train, labels, reg=0):\n", + " hidden_layer = np.maximum(0, np.dot(x_train, self.w[0]) + self.b[0])\n", + " scores = np.dot(hidden_layer, self.w[1]) + self.b[1]\n", + " probs = softmax(scores)\n", + " L = probs[range(probs.shape[0]),labels.astype('int64')]\n", + " L = np.nan_to_num(-np.log(L))\n", + " data_loss = np.sum(L)/L.shape[0]\n", + " if reg:\n", + " reg_loss1 = 0.5 * reg * np.sum(self.w[0] * self.w[0]) \n", + " reg_loss2 = 0.5 * reg * np.sum(self.w[1] * self.w[1])\n", + " reg_loss = reg_loss1 + reg_loss2\n", + " return (data_loss + reg_loss)\n", + " else:\n", + " return data_loss\n", + "\n", + " def SGD(self, x_train, y_train, epochs, mini_batch_size, step, reg=0):\n", + " training = [(x,y) for x,y in zip(x_train,y_train)]\n", + " n = len(x_train)\n", + " for i in range(epochs):\n", + " random.shuffle(training)\n", + " mini_batches = [training[k:k+mini_batch_size]\n", + " for k in range(0, n, mini_batch_size)]\n", + " \n", + " for mini_batch in mini_batches:\n", + " # forward\n", + " x_batch = np.concatenate([np.array(t[0]).reshape((1, 784)) for t in mini_batch])\n", + " y_batch = np.array([t[1] for t in mini_batch])\n", + " hidden_layer = np.maximum(0, np.dot(x_batch, self.w[0]) + self.b[0])\n", + " scores = np.dot(hidden_layer, self.w[1]) + self.b[1]\n", + " probs = softmax(scores)\n", + " # backward\n", + " dscores = probs\n", + " dscores[range(x_batch.shape[0]),y_batch.astype('int64')] -= 1\n", + " dscores /= x_batch.shape[0]\n", + " \n", + " dw2 = np.dot(hidden_layer.T, dscores)\n", + " db2 = np.sum(dscores, axis=0, keepdims=True)\n", + " dhidden = np.dot(dscores, (self.w[1]).T)\n", + " dhidden[hidden_layer <= 0] = 0\n", + " dw = np.dot(x_batch.T, dhidden)\n", + " db = np.sum(dhidden, axis=0, keepdims=True)\n", + " dw2 += reg * self.w[1]\n", + " dw += reg * self.w[0]\n", + " \n", + " # update\n", + " m = len(mini_batch)\n", + " self.w[0] += -step * dw / m\n", + " self.b[0] += -step * db / m\n", + " self.w[1] += -step * dw2 / m\n", + " self.b[1] += -step * db2 / m\n", + "\n", + " \n", + " # compute loss \n", + " if i % 10 ==0:\n", + " loss = self.loss_compute(x_train,y_train,reg)\n", + " print (\"iteration %d: loss %f\" % (i, loss)) \n", + "\n", + " def accuracy(self, x_test, y_test):\n", + " hidden_layer = np.maximum(0, np.dot(x_test, self.w[0]) + self.b[0])\n", + " scores = np.dot(hidden_layer,self.w[1] ) + self.b[1]\n", + " predict = np.argmax(scores, axis=1)\n", + " print('training accuracy: %.2f' % (np.mean(predict == y_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0: loss 0.297819\n", + "iteration 10: loss 0.095195\n", + "iteration 20: loss 0.098444\n", + "iteration 30: loss 0.089829\n", + "iteration 40: loss 0.088809\n", + "iteration 50: loss 0.085916\n", + "iteration 60: loss 0.080518\n", + "iteration 70: loss 0.083492\n", + "iteration 80: loss 0.092804\n", + "iteration 90: loss 0.080891\n", + "training accuracy: 0.98\n" + ] + } + ], + "source": [ + "np.random.seed(42)\n", + "net = Network([784, 100, 10])\n", + "net.SGD(train_data, train_id, 100, 30, 0.05, 0.05)\n", + "net.accuracy(test_data, test_id)" + ] + } + ], + "metadata": { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/assignment2/mnist.ipynb b/assignment2/mnist.ipynb new file mode 100644 index 0000000..b7ce672 --- /dev/null +++ b/assignment2/mnist.ipynb @@ -0,0 +1,1866 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import libraries and load in the mnist data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from PIL import Image\n", + "from glob import glob\n", + "import os.path as osp\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "from tqdm import tqdm_notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def load_data(train_path='train/', test_path='test/'):\n", + " train_list = glob(osp.join(train_path, '*.png'))\n", + " pattern = re.compile(r'num(\\d).png')\n", + " train_id = np.array([float(pattern.search(img_name).groups()[0]) for img_name in train_list])\n", + " train_data = np.concatenate([np.array(Image.open(img_name)).reshape((1, 784))for img_name in tqdm_notebook(train_list, leave=False)],\n", + " axis=0).astype(np.float)\n", + "\n", + " test_list = glob(osp.join(test_path, '*.png'))\n", + " test_id = np.array([float(pattern.search(img_name).groups()[0]) for img_name in test_list])\n", + " test_data = np.concatenate([np.array(Image.open(img_name)).reshape((1, 784)) for img_name in tqdm_notebook(test_list, leave=False)],\n", + " axis=0).astype(np.float)\n", + "\n", + " return train_data, train_id, test_data, test_id" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=60000), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=10000), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r" + ] + } + ], + "source": [ + "X, y, X_test, y_test = load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(60000, 784)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 784)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([8., 7., 4., ..., 2., 3., 6.])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Look at the data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(X[0].reshape((28, 28)), cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 26., 136.,\n", + " 255., 255., 121., 13., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 183., 254.,\n", + " 254., 254., 254., 27., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 106., 245., 254.,\n", + " 254., 215., 252., 170., 35., 76., 27., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 74., 245., 254., 247.,\n", + " 117., 30., 120., 248., 221., 254., 89., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 31., 227., 254., 126.,\n", + " 0., 0., 0., 73., 222., 248., 77., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 207., 254., 164.,\n", + " 0., 0., 0., 54., 235., 206., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 76., 254., 220.,\n", + " 0., 0., 0., 161., 254., 135., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 43., 228., 235.,\n", + " 45., 0., 48., 239., 187., 2., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 193., 254.,\n", + " 231., 44., 234., 254., 62., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 36., 150.,\n", + " 254., 230., 253., 181., 9., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 28.,\n", + " 235., 254., 254., 230., 61., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 152., 254., 254., 254., 230., 140., 28., 27., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 20.,\n", + " 210., 254., 251., 247., 249., 254., 254., 251., 145., 89., 5.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 35.,\n", + " 254., 254., 144., 0., 36., 154., 254., 254., 254., 254., 212.,\n", + " 27., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 35.,\n", + " 254., 254., 13., 0., 0., 3., 13., 17., 151., 193., 254.,\n", + " 211., 87., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 35.,\n", + " 254., 254., 51., 0., 0., 0., 0., 0., 0., 14., 105.,\n", + " 254., 213., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 8.,\n", + " 140., 254., 231., 55., 0., 0., 0., 0., 0., 0., 83.,\n", + " 254., 213., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 5., 167., 254., 228., 142., 12., 27., 46., 180., 180., 204.,\n", + " 254., 190., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 50., 156., 252., 254., 184., 221., 254., 254., 254., 247.,\n", + " 125., 28., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 104., 154., 254., 254., 254., 254., 123., 79.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X[0].reshape((28, 28))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Normalize our data by MinMax Scaler\n", + "\n", + "Which is, to divide every pixel by 255" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "X /= 255\n", + "X_test /= 255" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Split the data into mini-batches" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# feed 128 examples to network at a time\n", + "batch_size = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "X_mini_batches = [X[k:k+batch_size] for k in range(0, len(X), batch_size)]\n", + "y_mini_batches = [y[k:k+batch_size] for k in range(0, len(y), batch_size)]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((128, 784), (96, 784))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_mini_batches[0].shape, X_mini_batches[-1].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((128,), (96,))" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_mini_batches[0].shape, y_mini_batches[-1].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(469, 469)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(X_mini_batches), len(y_mini_batches)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Start building a SoftMax Classifier" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize parameters randomly\n", + "W = 0.01 * np.random.randn(784, 10)\n", + "b = np.zeros((1, 10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Forward Pass\n", + "Compute Class scores\n", + "$$\n", + "y_i=Wx_i+b\n", + "$$\n", + "Use SoftMax to convert from scores to probs\n", + "$$\n", + "p_{i,j}=\\frac{e^{y_{i,j}}}{\\sum_{k}e^{y_{i,k}}}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# We are gonna use the first mini batch for demo\n", + "X_batch, y_batch = X_mini_batches[0], y_mini_batches[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# compute class scores for a linear classifier\n", + "scores = np.dot(X_batch, W) + b\n", + "num_examples = X_batch.shape[0]\n", + "# get unnormalized probabilities\n", + "exp_scores = np.exp(scores)\n", + "# normalize them for each example\n", + "probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute the loss\n", + "Classification loss:\n", + "$$\n", + "L_i=-\\sum_{j}t_{i,j}log(p_{i,j})\n", + "$$\n", + "Regularization loss:\n", + "$$\n", + "L_{reg}=\\frac{1}{2}\\lambda \\|W\\|^2\n", + "$$\n", + "Over all loss:\n", + "$$\n", + "L=\\frac{1}{N}\\sum_{i}L_i+\\frac{1}{2}\\lambda \\|W\\|^2\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "correct_logprobs = -np.log(probs[range(num_examples), y_batch.astype(np.int)])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "reg = 1e-3" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# compute the loss: average cross-entropy loss and regularization\n", + "data_loss = np.sum(correct_logprobs) / num_examples\n", + "reg_loss = 0.5 * reg * np.sum(W * W)\n", + "loss = data_loss + reg_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.2928781582963933" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Backward Pass\n", + "$$\n", + "\\frac{\\partial L_i}{\\partial y_i}=p_i-t_i\n", + "$$\n", + "By apply the chain rule\n", + "$$\n", + "\\frac{\\partial L_i}{\\partial W}=\\frac{\\partial L_i}{\\partial y_i}\\frac{\\partial y_i}{\\partial W}\n", + "=\\frac{\\partial L_i}{\\partial y_i}x_i\\\\\n", + "$$\n", + "\n", + "\n", + "$$\n", + "\\frac{\\partial L_i}{\\partial b}=\\frac{\\partial L_i}{\\partial y_i}\\frac{\\partial y_i}{\\partial b}\n", + "=\\frac{\\partial L_i}{\\partial y_i}\n", + "$$\n", + "And the regularization term\n", + "$$\n", + "\\frac{\\partial }{\\partial W} (\\frac{1}{2}\\lambda \\|W\\|^2)=\\lambda W\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "dscores = probs\n", + "dscores[range(num_examples), y_batch.astype(np.int)] -= 1\n", + "dscores /= num_examples" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "dW = np.dot(X_batch.T, dscores)\n", + "db = np.sum(dscores, axis=0, keepdims=True)\n", + "dW += reg * W # don't forget the regularization gradient" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Update parameter" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# perform a parameter update\n", + "W += -0.01 * dW\n", + "b += -0.01 * db" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Form a training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "W = 0.01 * np.random.randn(784,10)\n", + "b = np.zeros((1,10))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "step_size = 1e-0\n", + "reg = 1e-3" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# define some function to increase readibility\n", + "def forward(W, b, reg, X_batch, y_batch):\n", + " # Forward pass\n", + " num_examples = X_batch.shape[0]\n", + " scores = np.dot(X_batch, W) + b\n", + " exp_scores = np.exp(scores)\n", + " probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)\n", + " # Compute loss\n", + " correct_logprobs = -np.log(probs[range(num_examples), y_batch.astype(np.int)])\n", + " data_loss = np.sum(correct_logprobs)/num_examples\n", + " reg_loss = 0.5*reg*np.sum(W*W)\n", + " loss = data_loss + reg_loss\n", + " return loss, probs" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def backward(W, b, reg, X_batch, y_batch, probs):\n", + " num_examples = X_batch.shape[0]\n", + " # Backward Pass\n", + " dscores = probs\n", + " dscores[range(num_examples), y_batch.astype(np.int)] -= 1\n", + " dscores /= num_examples\n", + " dW = np.dot(X_batch.T, dscores)\n", + " db = np.sum(dscores, axis=0, keepdims=True)\n", + " dW += reg * W # regularization gradient\n", + " return dW, db" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "332c7bc1e6c84981bbe40a440ee53059", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0: loss 2.307334\n", + "iteration 10: loss 0.409535\n", + "iteration 20: loss 0.409693\n", + "iteration 30: loss 0.409710\n", + "iteration 40: loss 0.409712\n", + "\n" + ] + } + ], + "source": [ + "for i in tqdm_notebook(range(50)):\n", + " for idx, (X_batch, y_batch) in enumerate(zip(X_mini_batches, y_mini_batches)):\n", + " loss, probs = forward(W, b, reg, X_batch, y_batch)\n", + " if i % 10 == 0 and idx == 0:\n", + " print(\"iteration %d: loss %f\" % (i, loss))\n", + " \n", + " dW, db = backward(W, b, reg, X_batch, y_batch, probs)\n", + "\n", + " # perform a parameter update\n", + " W += -step_size * dW\n", + " b += -step_size * db" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training accuracy: 0.90500\n" + ] + } + ], + "source": [ + "# evaluate training set accuracy\n", + "_, probs = forward(W, b, reg, X, y)\n", + "predicted_class = np.argmax(probs, axis=1)\n", + "print( 'training accuracy: %.5f' % (np.mean(predicted_class == y)))" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test accuracy: 0.90870\n" + ] + } + ], + "source": [ + "# evaluate training set accuracy\n", + "_, probs = forward(W, b, reg, X_test, y_test)\n", + "predicted_class = np.argmax(probs, axis=1)\n", + "print( 'test accuracy: %.5f' % (np.mean(predicted_class == y_test)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### SoftMax compared with multiple logistics regression model\n", + "\n", + "Gradient for SoftMax is \n", + "$$\n", + "\\frac{\\partial L_i}{\\partial W}=\\frac{\\partial L_i}{\\partial y_i}\\frac{\\partial y_i}{\\partial W}\n", + "=\\frac{\\partial L_i}{\\partial y_i}x_i\\\\\n", + "$$\n", + "\n", + "\n", + "$$\n", + "\\frac{\\partial L_i}{\\partial b}=\\frac{\\partial L_i}{\\partial y_i}\\frac{\\partial y_i}{\\partial b}\n", + "=\\frac{\\partial L_i}{\\partial y_i}\n", + "$$\n", + "\n", + "Where $\\frac{\\partial L_i}{\\partial y_i}$ is\n", + "$$\n", + "\\frac{\\partial L_i}{\\partial y_i}=p_i-t_i\n", + "$$\n", + "\n", + "Gradient for Logistics regression is\n", + "$$\n", + "\\frac{\\partial J(\\theta)}{\\partial \\theta}=\\sum_{i=1}^{m}(y_{\\theta}(x)-t^{(i)})x^{(i)}\n", + "$$\n", + "\n", + "So the Gradient for SoftMax and Logistics Regression is actually the same!\n", + "\n", + "One key different is that SoftMax can ensure that probability for every class can add up to 1, while Logistics Regression cannot.\n", + "\n", + "SoftMax is \n", + "$$\n", + "p_{i,j}=\\frac{e^{y_{i,j}}}{\\sum_{k}e^{y_{i,k}}}\n", + "$$\n", + "\n", + "Logistics Regression is\n", + "$$\n", + "y_{\\theta_i} = \\frac{1}{1+e^{-\\theta_i^Tx}}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(X_test[0].reshape((28, 28)), cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So SoftMax can force all probs to sum up to 1" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 1.0000000000000002)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.argmax(probs[0]), np.sum(probs[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# probs is the probability we get from X_test[0]\n", + "plt.bar(range(10), probs[0])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def get_classifier(X_train, y_train, num_epoch=1000, alpha=0.01):\n", + " theta = np.zeros((X_train.shape[1]))\n", + " for epoch in range(num_epoch):\n", + " # forward pass\n", + " logits = np.dot(X_train, theta)\n", + " h = 1 / (1 + np.exp(-logits))\n", + " cross_entropy_loss = (-y_train * np.log(h) - (1 - y_train) * np.log(1 - h)).mean()\n", + " \n", + " # backward pass\n", + " gradient = np.dot((h - y_train), X_train) / y.size\n", + " theta = theta - alpha * gradient\n", + " return theta\n", + "\n", + "def multi_classifier(X_train, y_train):\n", + " num_class = np.unique(y_train)\n", + " param = np.zeros((len(num_class), X_train.shape[1]))\n", + " \n", + " for i in tqdm_notebook(num_class):\n", + " label_t = np.zeros_like(y_train)\n", + " num_class = np.unique(y_train)\n", + " label_t[y_train == num_class[int(i)]] = 1\n", + " param[int(i), :] = get_classifier(X_train, label_t)\n", + " \n", + " return param" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2cb5833e891e4ab6a1823ffb805a6d0c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "W_logistic = multi_classifier(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "np.save('W_logistic.npy', W_logistic)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "W_logistic = np.load('W_logistic.npy')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "scores = np.dot(X_test[0], W_logistic.T)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "scores = 1 / (1 + np.exp(-scores))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 0.11885482362556947)" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.argmax(scores), np.sum(scores)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.48391378e-03, 1.16825283e-04, 7.59152825e-03, 7.85978369e-02,\n", + " 5.23101941e-05, 6.91530261e-03, 2.03889932e-02, 2.02595597e-04,\n", + " 3.34715722e-03, 1.58360624e-04])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(range(10), scores[0])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Two layer neural network" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize parameters randomly\n", + "h = 256 # size of hidden layer\n", + "W = 0.01 * np.random.randn(784,h)\n", + "b = np.zeros((1,h))\n", + "W2 = 0.01 * np.random.randn(h,10)\n", + "b2 = np.zeros((1,10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "X_batch, y_batch = X_mini_batches[0], y_mini_batches[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Two layer neural network as a automatic feature engineering\n", + "\n", + "Picture from the nndl-ebook\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# evaluate class scores with a 2-layer Neural Network\n", + "hidden_layer = np.maximum(0, np.dot(X_batch, W) + b) # note, ReLU activation\n", + "scores = np.dot(hidden_layer, W2) + b2" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "num_examples = X_batch.shape[0]\n", + "# get unnormalized probabilities\n", + "exp_scores = np.exp(scores)\n", + "# normalize them for each example\n", + "probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)\n", + "\n", + "correct_logprobs = -np.log(probs[range(num_examples), y_batch.astype(np.int)])" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "# compute the loss: average cross-entropy loss and regularization\n", + "data_loss = np.sum(correct_logprobs) / num_examples\n", + "reg_loss = 0.5 * reg * np.sum(W * W)\n", + "loss = data_loss + reg_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.3108377670883447" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "dscores = probs\n", + "dscores[range(num_examples), y_batch.astype(np.int)] -= 1\n", + "dscores /= num_examples" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "# backpropate the gradient to the parameters\n", + "# first backprop into parameters W2 and b2\n", + "dW2 = np.dot(hidden_layer.T, dscores)\n", + "db2 = np.sum(dscores, axis=0, keepdims=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Backward through ReLU\n", + "\n", + "The other part of the this two layer network is actually the same as before, \n", + "the only difference is the activation function ReLU.\n", + "\n", + "Since $ReLU(x)=max\\{0,x\\}$, We have that $\\frac{dReLU}{dx}=1(x>0)$, so ReLU is like a switch, kills off all the activation below 0." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "dhidden = np.dot(dscores, W2.T)\n", + "# backprop the ReLU non-linearity\n", + "dhidden[hidden_layer <= 0] = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "# finally into W,b\n", + "dW = np.dot(X_batch.T, dhidden)\n", + "db = np.sum(dhidden, axis=0, keepdims=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "W += -step_size * dW\n", + "b += -step_size * db\n", + "W2 += -step_size * dW2\n", + "b2 += -step_size * db2" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def forward(W, b, W2, b2, reg, X_batch, y_batch):\n", + " num_examples = X_batch.shape[0]\n", + " # evaluate class scores with a 2-layer Neural Network\n", + " hidden_layer = np.maximum(0, np.dot(X_batch, W) + b) # note, ReLU activation\n", + " scores = np.dot(hidden_layer, W2) + b2\n", + " \n", + " # get unnormalized probabilities\n", + " exp_scores = np.exp(scores)\n", + " # normalize them for each example\n", + " probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)\n", + "\n", + " correct_logprobs = -np.log(probs[range(num_examples), y_batch.astype(np.int)])\n", + " \n", + " # compute the loss: average cross-entropy loss and regularization\n", + " data_loss = np.sum(correct_logprobs) / num_examples\n", + " reg_loss = 0.5 * reg * np.sum(W * W)\n", + " loss = data_loss + reg_loss\n", + " return loss, probs, hidden_layer" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "def backward(W, b, W2, b2, reg, X_batch, hidden_layer, y_batch, probs):\n", + " num_examples = X_batch.shape[0]\n", + " dscores = probs\n", + " dscores[range(num_examples), y_batch.astype(np.int)] -= 1\n", + " dscores /= num_examples\n", + " \n", + " # backpropate the gradient to the parameters\n", + " # first backprop into parameters W2 and b2\n", + " dW2 = np.dot(hidden_layer.T, dscores)\n", + " db2 = np.sum(dscores, axis=0, keepdims=True)\n", + " \n", + " dhidden = np.dot(dscores, W2.T)\n", + " # backprop the ReLU non-linearity\n", + " dhidden[hidden_layer <= 0] = 0\n", + " \n", + " # finally into W,b\n", + " dW = np.dot(X_batch.T, dhidden)\n", + " db = np.sum(dhidden, axis=0, keepdims=True)\n", + " return dW, db, dW2, db2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Why ReLU, Why not sigmoid?\n", + "\n", + "Sigmoid is defined as \n", + "$$\n", + "sigmoid(z)=\\frac{1}{1+e^{-z}}\n", + "$$\n", + "ReLU is \n", + "$$\n", + "ReLU(z)=max\\{0,z\\}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "def sigmoid(z):\n", + " return 1 / (1+np.exp(-z))\n", + "def relu(z):\n", + " return np.maximum(z, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_function(function, title=\"sigmoid\"):\n", + " plt.figure()\n", + " x = np.arange(-7, 7, 0.01)\n", + " y = function(x)\n", + " print(y)\n", + " plt.plot(x, y)\n", + " plt.xlabel(\"x\")\n", + " plt.ylabel(\"y\")\n", + " plt.title(title)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[9.11051194e-04 9.20198986e-04 9.29438544e-04 ... 9.99061229e-01\n", + " 9.99070561e-01 9.99079801e-01]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_function(sigmoid, \"sigmoid\")" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0. 0. ... 6.97 6.98 6.99]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_function(relu, \"ReLU\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we compute the gradient for both sigmoid and ReLU, We can get\n", + "\n", + "$$\n", + "\\frac{\\partial sigmoid(z)}{\\partial z}=sigmoid(z)*(1-sigmoid(z))\n", + "$$\n", + "and\n", + "$$\n", + "\\frac{\\partial relu(z)}{\\partial z}=1(z>0)\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "def sigmoid_derivative(z):\n", + " return sigmoid(z) * (1 - sigmoid(z))\n", + "\n", + "def relu_derivative(z):\n", + " z[z <= 0] = 0\n", + " z[z > 0] = 1\n", + " return z" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.00091022 0.00091935 0.00092857 ... 0.00093789 0.00092857 0.00091935]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_function(sigmoid_derivative, \"sigmoid derivative\")" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0. 0. ... 1. 1. 1.]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_function(relu_derivative, \"relu derivative\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You will notice that the derivative of sigmoid never actually goes over 0.25, ReLU on the other hand, has a larger derivative.\n", + "\n", + "Recall that when we update the parameters, \n", + "$$\n", + "\\theta=\\theta-\\alpha \\frac{\\partial Cost}{\\partial \\theta}\n", + "$$\n", + "\n", + "Small $\\frac{\\partial Cost}{\\partial \\theta}$ means slow Learning, so that sigmoid is actually not a good option if we want to learn a model fast." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Form a Training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize parameters randomly\n", + "h = 256 # size of hidden layer\n", + "W = 0.01 * np.random.randn(784,h)\n", + "b = np.zeros((1,h))\n", + "W2 = 0.01 * np.random.randn(h,10)\n", + "b2 = np.zeros((1,10))" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "# some hyperparameters\n", + "step_size = 1e-3\n", + "reg = 1e-3 # regularization strength" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "code_folding": [], + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8916f28fb3ec4203aad667a21b4cf8e5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=1000), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0: loss 2.311251\n", + "iteration 50: loss 0.425484\n", + "iteration 100: loss 0.339399\n", + "iteration 150: loss 0.311571\n", + "iteration 200: loss 0.291808\n", + "iteration 250: loss 0.272548\n", + "iteration 300: loss 0.254677\n", + "iteration 350: loss 0.237345\n", + "iteration 400: loss 0.221120\n", + "iteration 450: loss 0.205970\n", + "iteration 500: loss 0.193160\n", + "iteration 550: loss 0.182102\n", + "iteration 600: loss 0.172023\n", + "iteration 650: loss 0.162890\n", + "iteration 700: loss 0.155158\n", + "iteration 750: loss 0.148236\n", + "iteration 800: loss 0.142088\n", + "iteration 850: loss 0.136730\n", + "iteration 900: loss 0.132154\n", + "iteration 950: loss 0.128225\n", + "\n" + ] + } + ], + "source": [ + "# gradient descent loop\n", + "for i in tqdm_notebook(range(1000)):\n", + " for idx, (X_batch, y_batch) in enumerate(zip(X_mini_batches, y_mini_batches)):\n", + " loss, probs, hidden_layer = forward(W, b, W2, b2, reg, X_batch, y_batch)\n", + " if i % 50 == 0 and idx == 0:\n", + " print( \"iteration %d: loss %f\" % (i, loss))\n", + "\n", + " dW, db, dW2, db2 = backward(W, b, W2, b2, reg, X_batch, hidden_layer, y_batch, probs)\n", + " \n", + " # perform a parameter update\n", + " W += -step_size * dW\n", + " b += -step_size * db\n", + " W2 += -step_size * dW2\n", + " b2 += -step_size * db2" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "# Save the trained weight\n", + "np.savez('weights.npz', W, b, W2, b2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "weights = np.load('weights.npz')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "W, b, W2, b2 = weights['arr_0'], weights['arr_1'], weights['arr_2'], weights['arr_3']" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training accuracy: 0.9727\n" + ] + } + ], + "source": [ + "# evaluate training set accuracy\n", + "hidden_layer = np.maximum(0, np.dot(X, W) + b)\n", + "scores = np.dot(hidden_layer, W2) + b2\n", + "predicted_class = np.argmax(scores, axis=1)\n", + "print( 'training accuracy: %.4f' % (np.mean(predicted_class == y)))" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test accuracy: 0.9664\n" + ] + } + ], + "source": [ + "# evaluate test set accuracy\n", + "hidden_layer = np.maximum(0, np.dot(X_test, W) + b)\n", + "scores = np.dot(hidden_layer, W2) + b2\n", + "predicted_class = np.argmax(scores, axis=1)\n", + "print( 'test accuracy: %.4f' % (np.mean(predicted_class == y_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 0, 0, ..., 0, 0, 0])" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 - (predicted_class == y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(X_test[(1 - (predicted_class == y_test)).astype(np.bool)][0].reshape((28, 28)), cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9.0" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_test[(1 - (predicted_class == y_test)).astype(np.bool)][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predicted_class[(1 - (predicted_class == y_test)).astype(np.bool)][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(X[0].reshape((28, 28)), cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(W[:, 0].reshape((28, 28)) * X[0].reshape((28, 28)))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(W[:, 0].reshape((28, 28)), cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(W[:, 2].reshape((28, 28)), cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.7.0" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/assignment2/mnist_loader.py b/assignment2/mnist_loader.py new file mode 100644 index 0000000..a29c7ec --- /dev/null +++ b/assignment2/mnist_loader.py @@ -0,0 +1,13 @@ +def load_data(train_path='train/', test_path='test/'): + train_list = glob(osp.join(train_path, '*.png')) + pattern = re.compile(r'num(\d).png') + train_id = np.array([float(pattern.search(img_name).groups()[0]) for img_name in train_list]) + train_data = np.concatenate([np.array(Image.open(img_name)).reshape((1, 784))for img_name in tqdm_notebook(train_list, leave=False)], + axis=0).astype(np.float) + + test_list = glob(osp.join(test_path, '*.png')) + test_id = np.array([float(pattern.search(img_name).groups()[0]) for img_name in test_list]) + test_data = np.concatenate([np.array(Image.open(img_name)).reshape((1, 784)) for img_name in tqdm_notebook(test_list, leave=False)], + axis=0).astype(np.float) + + return train_data, train_id, test_data, test_id \ No newline at end of file diff --git a/assignment2/pics/formula1.PNG b/assignment2/pics/formula1.PNG new file mode 100644 index 0000000..b56990b Binary files /dev/null and b/assignment2/pics/formula1.PNG differ diff --git a/assignment2/pics/formula2.PNG b/assignment2/pics/formula2.PNG new file mode 100644 index 0000000..d4bc1e2 Binary files /dev/null and b/assignment2/pics/formula2.PNG differ diff --git a/assignment2/pics/mnist.png b/assignment2/pics/mnist.png new file mode 100644 index 0000000..5f9d973 Binary files /dev/null and b/assignment2/pics/mnist.png differ diff --git a/assignment3/assignment3-pytorch.ipynb b/assignment3/assignment3-pytorch.ipynb new file mode 100644 index 0000000..6681835 --- /dev/null +++ b/assignment3/assignment3-pytorch.ipynb @@ -0,0 +1,501 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "import torchvision.transforms as transforms" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Download the dataset " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "0it [00:00, ?it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 170418176/170498071 [01:56<00:00, 1705978.52it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting ./data/cifar-10-python.tar.gz to ./data\n", + "Files already downloaded and verified\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "170500096it [02:10, 1705978.52it/s] " + ] + } + ], + "source": [ + "transform = transforms.Compose(\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n", + "\n", + "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n", + " download=True, transform=transform)\n", + "trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,\n", + " shuffle=True, num_workers=2)\n", + "\n", + "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n", + " download=True, transform=transform)\n", + "testloader = torch.utils.data.DataLoader(testset, batch_size=4,\n", + " shuffle=False, num_workers=2)\n", + "\n", + "classes = ('plane', 'car', 'bird', 'cat',\n", + " 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# functions to show an image\n", + "\n", + "def imshow(img):\n", + " img = img / 2 + 0.5 # unnormalize\n", + " npimg = img.numpy()\n", + " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", + " plt.show()\n", + "\n", + "dataiter = iter(trainloader)\n", + "images, labels = dataiter.next()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "imshow(torchvision.utils.make_grid(images))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " cat ship dog cat\n" + ] + } + ], + "source": [ + "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define a Convolutional Neural Network" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "class Net(nn.Module):\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(3, 16, 5) # in_channels = 3, out_channels = 6, kernel_size = 5x5, stride = 1\n", + " self.pool = nn.MaxPool2d(2, 2) # kernel_size = 2, stride = 2\n", + " self.conv2 = nn.Conv2d(16, 32, 5)\n", + " self.fc1 = nn.Linear(32 * 5 * 5, 120) # y = Ax+b: in_features = 16x5x5, out_features = 120 \n", + " self.fc2 = nn.Linear(120, 84)\n", + " self.fc3 = nn.Linear(84, 10)\n", + "\n", + " def forward(self, x):\n", + " x = self.pool(F.relu(self.conv1(x)))\n", + " x = self.pool(F.relu(self.conv2(x)))\n", + " x = x.view(-1, 32 * 5 * 5) \n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.fc2(x))\n", + " x = self.fc3(x)\n", + " return x\n", + "\n", + "net = Net()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.optim as optim\n", + "\n", + "criterion = nn.CrossEntropyLoss() # loss function \n", + "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the network" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda:0\n" + ] + } + ], + "source": [ + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "print(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Net(\n", + " (conv1): Conv2d(3, 16, kernel_size=(5, 5), stride=(1, 1))\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (conv2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1))\n", + " (fc1): Linear(in_features=800, out_features=120, bias=True)\n", + " (fc2): Linear(in_features=120, out_features=84, bias=True)\n", + " (fc3): Linear(in_features=84, out_features=10, bias=True)\n", + ")" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "net.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2000] loss: 2.149\n", + "[1, 4000] loss: 1.784\n", + "[1, 6000] loss: 1.619\n", + "[1, 8000] loss: 1.512\n", + "[1, 10000] loss: 1.431\n", + "[1, 12000] loss: 1.359\n", + "[2, 2000] loss: 1.302\n", + "[2, 4000] loss: 1.260\n", + "[2, 6000] loss: 1.236\n", + "[2, 8000] loss: 1.170\n", + "[2, 10000] loss: 1.152\n", + "[2, 12000] loss: 1.133\n", + "[3, 2000] loss: 1.024\n", + "[3, 4000] loss: 1.041\n", + "[3, 6000] loss: 1.016\n", + "[3, 8000] loss: 1.026\n", + "[3, 10000] loss: 0.999\n", + "[3, 12000] loss: 1.002\n", + "[4, 2000] loss: 0.903\n", + "[4, 4000] loss: 0.894\n", + "[4, 6000] loss: 0.912\n", + "[4, 8000] loss: 0.903\n", + "[4, 10000] loss: 0.894\n", + "[4, 12000] loss: 0.889\n", + "[5, 2000] loss: 0.801\n", + "[5, 4000] loss: 0.816\n", + "[5, 6000] loss: 0.815\n", + "[5, 8000] loss: 0.826\n", + "[5, 10000] loss: 0.829\n", + "[5, 12000] loss: 0.808\n", + "Finished Training\n" + ] + } + ], + "source": [ + "for epoch in range(5): # loop over the dataset multiple times\n", + "\n", + " running_loss = 0.0\n", + " for i, data in enumerate(trainloader, 0):\n", + " # get the inputs; data is a list of [inputs, labels]\n", + " inputs, labels = data[0].to(device), data[1].to(device)\n", + " # zero the parameter gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # forward + backward + optimize\n", + " outputs = net(inputs)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # print statistics\n", + " running_loss += loss.item()\n", + " if i % 2000 == 1999: # print every 2000 mini-batches\n", + " print('[%d, %5d] loss: %.3f' %\n", + " (epoch + 1, i + 1, running_loss / 2000))\n", + " running_loss = 0.0\n", + "\n", + "print('Finished Training')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Save the model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "PATH = './cifar_net.pth'\n", + "torch.save(net.state_dict(), PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test the network" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "dataiter = iter(testloader)\n", + "images, labels = dataiter.next()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GroundTruth: cat ship ship plane\n" + ] + } + ], + "source": [ + "imshow(torchvision.utils.make_grid(images))\n", + "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "images = images.to(device)\n", + "outputs = net(images)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted: cat ship car plane\n" + ] + } + ], + "source": [ + "_, predicted = torch.max(outputs, 1)\n", + "\n", + "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]\n", + " for j in range(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the network on the 10000 test images: 68 %\n" + ] + } + ], + "source": [ + "correct = 0\n", + "total = 0\n", + "with torch.no_grad():\n", + " for data in testloader:\n", + " images, labels = data[0].to(device), data[1].to(device)\n", + " outputs = net(images)\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + "print('Accuracy of the network on the 10000 test images: %d %%' % (\n", + " 100 * correct / total))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of plane : 72 %\n", + "Accuracy of car : 86 %\n", + "Accuracy of bird : 53 %\n", + "Accuracy of cat : 70 %\n", + "Accuracy of deer : 58 %\n", + "Accuracy of dog : 41 %\n", + "Accuracy of frog : 79 %\n", + "Accuracy of horse : 66 %\n", + "Accuracy of ship : 77 %\n", + "Accuracy of truck : 74 %\n" + ] + } + ], + "source": [ + "class_correct = list(0. for i in range(10))\n", + "class_total = list(0. for i in range(10))\n", + "with torch.no_grad():\n", + " for data in testloader:\n", + " images, labels = data[0].to(device), data[1].to(device)\n", + " outputs = net(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " c = (predicted == labels).squeeze()\n", + " for i in range(4):\n", + " label = labels[i]\n", + " class_correct[label] += c[i].item()\n", + " class_total[label] += 1\n", + "\n", + "\n", + "for i in range(10):\n", + " print('Accuracy of %5s : %2d %%' % (\n", + " classes[i], 100 * class_correct[i] / class_total[i]))" + ] + } + ], + "metadata": { + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/assignment3/assignment3.ipynb b/assignment3/assignment3.ipynb new file mode 100644 index 0000000..be0f3cf --- /dev/null +++ b/assignment3/assignment3.ipynb @@ -0,0 +1,803 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CIFAR-10 classifier with CNN\n", + "\n", + "![](pics/data.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task 1: Forward pass and Backward pass for Convolution\n", + "\n", + "Implement a naive conv_forward function and apply the vertical and horizontal filter on example images\n", + "\n", + "Implement a conv_forward using im2col and also apply the filter on example images\n", + "\n", + "Implement a conv_backward using im2col and do some numerical gradient test" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.datasets import load_sample_image" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "china = load_sample_image('china.jpg')[150:220, 130:250] / 255\n", + "flower = load_sample_image(\"flower.jpg\")[150:220, 130:250] / 255\n", + "images = np.array([china, flower])\n", + "batch_size, height, width, channels = images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import sklearn\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Create 2 filters\n", + "filters = np.zeros(shape=(7, 7, channels, 2), dtype=np.float32)\n", + "filters[:, 3, :, 0] = 1 # vertical line\n", + "filters[3, :, :, 1] = 1 # horizontal line" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.subplot(1, 2, 1)\n", + "plt.imshow(filters[:, :, 0, 0])\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(filters[:, :, 0, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 15))\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(china)\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(flower)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install torch torchvision -i https://pypi.douban.com/simple" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# if you don't have torch and torchvision \n", + "# uncomment and run the above cell \n", + "import torch\n", + "import torch.nn.functional as F" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "filters = np.transpose(filters, (3, 2, 0, 1))\n", + "# We will want our image to be NCHW format for pytorch to process\n", + "images = np.transpose(images, (0, 3, 1, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Example on convolution using pytorch\n", + "images_tensor = torch.Tensor(images)\n", + "filters_tensor = torch.Tensor(filters)\n", + "outputs = F.conv2d(images_tensor, filters_tensor, )" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "china_convolved = outputs[0].numpy()\n", + "flower_convolved = outputs[1].numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "china_convolved = np.transpose(china_convolved, (1, 2, 0))\n", + "flower_convolved = np.transpose(flower_convolved, (1, 2, 0))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 20))\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(china_convolved[:, :, 0], cmap='gray')\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(china_convolved[:, :, 1], cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def conv_forward_naive(x, w, b=None, pad=0, strides=1):\n", + " \"\"\"\n", + " A naive implementation of the forward pass for a convolutional layer.\n", + " The input consists of N data points, each with C channels, height H and width\n", + " W. We convolve each input with F different filters, where each filter spans\n", + " all C channels and has height HH and width HH.\n", + " Input:\n", + " - x: Input data of shape (N, C, H, W)\n", + " - w: Filter weights of shape (F, C, HH, WW)\n", + " - b: Biases, of shape (F,)\n", + " - stride: The number of pixels between adjacent receptive fields in the\n", + " horizontal and vertical directions.\n", + " - pad: The number of pixels that will be used to zero-pad the input.\n", + " Returns a tuple of:\n", + " - out: Output data, of shape (N, F, H', W') where H' and W' are given by\n", + " H' = 1 + (H + 2 * pad - HH) / stride\n", + " W' = 1 + (W + 2 * pad - WW) / stride\n", + " - cache: (x, w, b, pad, strides)\n", + " \"\"\"\n", + " out = None\n", + " N, C, H, W = x.shape\n", + " F, C, HH, WW = w.shape\n", + " S = strides\n", + " P = pad\n", + " \n", + " if b is None:\n", + " b = np.zeros((F))\n", + "\n", + " \"\"\"\n", + " TODO: write your code here\n", + " \"\"\"\n", + "\n", + " cache = (x, w, b, pad, strides)\n", + " return out, cache" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\n Here apply you implmentation of convolution on the sample images\\n and show the result\\n'" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + " Here apply you implmentation of convolution on the sample images\n", + " and show the result\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### im2col\n", + "\n", + "it turns out that we can use a clever algorithm called\n", + "im2col to convert a image to a matrix and the convolution\n", + "(which we naively implement using for-loops) will be \n", + "a single matrix multiplication\n", + "\n", + "check this [url](http://cs231n.github.io/convolutional-networks/#conv) and Yangqing's memo [Conv in Caffe](https://github.com/Yangqing/caffe/wiki/Convolution-in-Caffe:-a-memo)\n", + "\n", + "![](pics/1.jpg)\n", + "\n", + "\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def im2col(image, ksize, stride):\n", + " \"\"\"\n", + " TODO: Implement a im2col to NCHW format images\n", + " \"\"\"\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def conv_forward_im2col(x, w, b=None, pad=0, strides=1):\n", + " \"\"\"\n", + " TODO: Implement conv_forward using im2col\n", + " \"\"\"\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\n Here apply you implmentation of convolution on the sample images\\n and show the result\\n'" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + " Here apply you implmentation of convolution on the sample images\n", + " and show the result\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def conv_backward_im2col(dout, cache):\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can actually sees that the gradient through the convolution is\n", + "the rotated kernel convolves over the error from later layer\n", + "\n", + "(if you prefer solid math over this visual proof, check [this](https://grzegorzgwardys.wordpress.com/2016/04/22/8/) [this](https://www.jefkine.com/general/2016/09/05/backpropagation-in-convolutional-neural-networks/) and this [lecture notes](http://courses.cs.tau.ac.il/Caffe_workshop/Bootcamp/pdf_lectures/Lecture%203%20CNN%20-%20backpropagation.pdf))\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def eval_numerical_gradient_array(f, x, df, h=1e-5):\n", + " \"\"\"\n", + " Evaluate a numeric gradient for a function that accepts a numpy\n", + " array and returns a numpy array.\n", + " \"\"\"\n", + " grad = np.zeros_like(x)\n", + " it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])\n", + " while not it.finished:\n", + " ix = it.multi_index\n", + "\n", + " oldval = x[ix]\n", + " x[ix] = oldval + h\n", + " pos = f(x).copy()\n", + " x[ix] = oldval - h\n", + " neg = f(x).copy()\n", + " x[ix] = oldval\n", + "\n", + " grad[ix] = np.sum((pos - neg) * df) / (2 * h)\n", + " it.iternext()\n", + " return grad" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You relative error from the below cell output should be around 1e-9" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'np' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mw\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mdout\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mstride\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpad\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'np' is not defined" + ] + } + ], + "source": [ + "x = np.random.randn(4, 3, 5, 5)\n", + "w = np.random.randn(2, 3, 3, 3)\n", + "b = np.random.randn(2,)\n", + "dout = np.random.randn(4, 2, 5, 5)\n", + "stride, pad = 1, 1\n", + "\n", + "dx_num = eval_numerical_gradient_array(lambda x: conv_forward_im2col(x, w, b, pad, stride)[0], x, dout)\n", + "dw_num = eval_numerical_gradient_array(lambda w: conv_forward_im2col(x, w, b, pad, stride)[0], w, dout)\n", + "db_num = eval_numerical_gradient_array(lambda b: conv_forward_im2col(x, w, b, pad, stride)[0], b, dout)\n", + "\n", + "out, cache = conv_forward_im2col(x, w, b, pad, stride)\n", + "dx, dw, db = conv_backward_im2col(dout, cache)\n", + "\n", + "def rel_error(x, y):\n", + " \"\"\" returns relative error \"\"\"\n", + " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n", + "\n", + "print(\"dx error: \", rel_error(dx, dx_num))\n", + "print(\"dw error: \", rel_error(dw, dw_num))\n", + "print(\"db error: \", rel_error(db, db_num))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task 2: Forward pass and backward pass of other layers\n", + "\n", + "\n", + "\n", + "\n", + "
\"3\"\"3\"
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "you can choose either pool method and implement" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def pool_forward(x, height, width, ksize, method):\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass\n", + "def pool_backward(x, height, width, ksize, method):\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def fc_forward(x, w, b):\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass\n", + "\n", + "def fc_backward(dout, cache):\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def relu_forward(x):\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass\n", + "def relu_backward(dout, cache):\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def softmax_loss(x, y):\n", + " \"\"\"\n", + " Computes the loss and gradient for softmax classification.\n", + "\n", + " Inputs:\n", + " - x: Input data, of shape (N, C) where x[i, j] is the score for the jth class\n", + " for the ith input.\n", + " - y: Vector of labels, of shape (N,) where y[i] is the label for x[i] and\n", + " 0 <= y[i] < C\n", + "\n", + " Returns a tuple of:\n", + " - loss: Scalar giving the loss\n", + " - probs: The predicted probability\n", + " - dx: Gradient of the loss with respect to x\n", + " \"\"\"\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task3: Combine all this together and train a CNN on CIFAR-10!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can use an arch samiliar to LeNet ![](https://images2017.cnblogs.com/blog/1093303/201802/1093303-20180217131615671-367457714.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. overfit a small data(achieve 100% accuracy on a small data)\n", + "2. train on the whole training data, validation on validation data, finally test on test data" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install torch torchvision -i https://pypi.douban.com/simple" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import torchvision\n", + "\n", + "# I'm using torchvision to load the CIFAR10 dataset\n", + "# if you don't have torch and torchvision \n", + "# uncomment and run the above cell \n", + "def load_cifar(path='./data'):\n", + " cifar_train = torchvision.datasets.cifar.CIFAR10(path, download=True)\n", + " cifar_test = torchvision.datasets.cifar.CIFAR10(path, download=True, train=False)\n", + "\n", + " cifar_train_img_list, cifar_train_label_list = [], []\n", + " for train_example in cifar_train:\n", + " img = np.array(train_example[0])[np.newaxis, :]\n", + " label = train_example[1]\n", + " cifar_train_img_list.append(img)\n", + " cifar_train_label_list.append(label)\n", + " cifar_train_img = np.concatenate(cifar_train_img_list, axis=0).astype(np.float) / 255\n", + " cifar_train_label = np.array(cifar_train_label_list).astype(np.int)\n", + "\n", + " cifar_test_img_list, cifar_test_label_list = [], []\n", + " for test_example in cifar_test:\n", + " img = np.array(test_example[0])[np.newaxis, :]\n", + " label = test_example[1]\n", + " cifar_test_img_list.append(img)\n", + " cifar_test_label_list.append(label)\n", + " cifar_test_img = np.concatenate(cifar_test_img_list, axis=0).astype(np.float) / 255\n", + " cifar_test_label = np.array(cifar_test_label_list).astype(np.int)\n", + "\n", + " return cifar_train_img[:49000], cifar_train_label[:49000], \\\n", + " cifar_train_img[49000:], cifar_train_label[49000:], \\\n", + " cifar_test_img, cifar_test_label" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], + "source": [ + "X, y, X_val, y_val, X_test, y_test = load_cifar()\n", + "X = np.transpose(X, (0, 3, 1, 2))\n", + "X_val = np.transpose(X_val, (0, 3, 1, 2))\n", + "X_test = np.transpose(X_test, (0, 3, 1, 2))\n", + "batch_size = 64\n", + "X_mini_batches = [X[k:k+batch_size] for k in range(0, len(X), batch_size)]\n", + "y_mini_batches = [y[k:k+batch_size] for k in range(0, len(y), batch_size)]\n", + "X_dummy = X[:100]\n", + "y_dummy = y[:100]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((49000, 3, 32, 32),\n", + " (49000,),\n", + " (1000, 3, 32, 32),\n", + " (1000,),\n", + " (10000, 3, 32, 32),\n", + " (10000,))" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape, y.shape, X_val.shape, y_val.shape, X_test.shape, y_test.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check if you have any bug by overfitting a small dat" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((100, 3, 32, 32), (100,))" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_dummy.shape, y_dummy.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for epoch in range(200):\n", + " alpha = 0.1\n", + " reg = 0.01\n", + " # forward pass through network using X_dummy\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " #from ipdb import set_trace; set_trace()\n", + " # Calculate the loss\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " \n", + " \n", + "\n", + " acc = np.mean(np.argmax(pred, axis=1) == y_dummy)\n", + " if epoch % 20 == 0:\n", + " #print('dloss: ', dloss)\n", + " print('epoch:', epoch, 'loss:', loss)\n", + " print('epoch:', epoch, 'reg_loss:', reg_loss)\n", + " print('epoch:', epoch, 'acc:', acc)\n", + "\n", + " # backward pass through network\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"\n", + " \n", + " # update parameter\n", + " \"\"\"\n", + " TODO\n", + " \"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train on the whole dataset\n", + "\n", + "```python\n", + "for epoch in range(num_epoch):\n", + " for X_batch, y_batch in zip(X_batches, y_batches)\n", + " forward(X_batch)\n", + " loss(pred, y_batch)\n", + " backward()\n", + " update()\n", + " if epoch % interval == 0:\n", + " validate(X_val, y_val)\n", + "\n", + "test(X_test, y_test)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/assignment3/pics/.ipynb_checkpoints/1-checkpoint.jpg b/assignment3/pics/.ipynb_checkpoints/1-checkpoint.jpg new file mode 100644 index 0000000..d170108 Binary files /dev/null and b/assignment3/pics/.ipynb_checkpoints/1-checkpoint.jpg differ diff --git a/assignment3/pics/.ipynb_checkpoints/6-checkpoint.jpg b/assignment3/pics/.ipynb_checkpoints/6-checkpoint.jpg new file mode 100644 index 0000000..c563cc8 Binary files /dev/null and b/assignment3/pics/.ipynb_checkpoints/6-checkpoint.jpg differ diff --git a/assignment3/pics/1.jpg b/assignment3/pics/1.jpg new file mode 100644 index 0000000..d170108 Binary files /dev/null and b/assignment3/pics/1.jpg differ diff --git a/assignment3/pics/10.jpg b/assignment3/pics/10.jpg new file mode 100644 index 0000000..431be6b Binary files /dev/null and b/assignment3/pics/10.jpg differ diff --git a/assignment3/pics/11.jpg b/assignment3/pics/11.jpg new file mode 100644 index 0000000..020ddac Binary files /dev/null and b/assignment3/pics/11.jpg differ diff --git a/assignment3/pics/2.jpg b/assignment3/pics/2.jpg new file mode 100644 index 0000000..c2f4da7 Binary files /dev/null and b/assignment3/pics/2.jpg differ diff --git a/assignment3/pics/3.jpg b/assignment3/pics/3.jpg new file mode 100644 index 0000000..55fb5c8 Binary files /dev/null and b/assignment3/pics/3.jpg differ diff --git a/assignment3/pics/4.jpg b/assignment3/pics/4.jpg new file mode 100644 index 0000000..8cfb824 Binary files /dev/null and b/assignment3/pics/4.jpg differ diff --git a/assignment3/pics/5.jpg b/assignment3/pics/5.jpg new file mode 100644 index 0000000..f906bc2 Binary files /dev/null and b/assignment3/pics/5.jpg differ diff --git a/assignment3/pics/6.jpg b/assignment3/pics/6.jpg new file mode 100644 index 0000000..c563cc8 Binary files /dev/null and b/assignment3/pics/6.jpg differ diff --git a/assignment3/pics/7.jpg b/assignment3/pics/7.jpg new file mode 100644 index 0000000..404d867 Binary files /dev/null and b/assignment3/pics/7.jpg differ diff --git a/assignment3/pics/8.jpg b/assignment3/pics/8.jpg new file mode 100644 index 0000000..02ed391 Binary files /dev/null and b/assignment3/pics/8.jpg differ diff --git a/assignment3/pics/9.jpg b/assignment3/pics/9.jpg new file mode 100644 index 0000000..5865aae Binary files /dev/null and b/assignment3/pics/9.jpg differ diff --git a/assignment3/pics/cnn_gradient_finger.png b/assignment3/pics/cnn_gradient_finger.png new file mode 100644 index 0000000..898bac4 Binary files /dev/null and b/assignment3/pics/cnn_gradient_finger.png differ diff --git a/assignment3/pics/convolution-mlp-mapping.png b/assignment3/pics/convolution-mlp-mapping.png new file mode 100644 index 0000000..b8148f7 Binary files /dev/null and b/assignment3/pics/convolution-mlp-mapping.png differ diff --git a/assignment3/pics/data.png b/assignment3/pics/data.png new file mode 100644 index 0000000..73ec803 Binary files /dev/null and b/assignment3/pics/data.png differ diff --git a/assignment3/pics/image-13-conv-cnn.gif b/assignment3/pics/image-13-conv-cnn.gif new file mode 100644 index 0000000..41628db Binary files /dev/null and b/assignment3/pics/image-13-conv-cnn.gif differ diff --git a/assignment3/pics/konwolucja.png b/assignment3/pics/konwolucja.png new file mode 100644 index 0000000..fd5a375 Binary files /dev/null and b/assignment3/pics/konwolucja.png differ diff --git a/assignment3/pics/screenshot-from-2016-04-17-212043.png b/assignment3/pics/screenshot-from-2016-04-17-212043.png new file mode 100644 index 0000000..29a1838 Binary files /dev/null and b/assignment3/pics/screenshot-from-2016-04-17-212043.png differ diff --git a/assignment4/assignment4.ipynb b/assignment4/assignment4.ipynb new file mode 100644 index 0000000..f44e697 --- /dev/null +++ b/assignment4/assignment4.ipynb @@ -0,0 +1,820 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Neural Transfer Using PyTorch\n", + "=============================\n", + "\n", + "\n", + "**Author**: `Alexis Jacq `_\n", + " \n", + "**Edited by**: `Winston Herring `_\n", + "\n", + "Introduction\n", + "------------\n", + "\n", + "This tutorial explains how to implement the `Neural-Style algorithm `__\n", + "developed by Leon A. Gatys, Alexander S. Ecker and Matthias Bethge.\n", + "Neural-Style, or Neural-Transfer, allows you to take an image and\n", + "reproduce it with a new artistic style. The algorithm takes three images,\n", + "an input image, a content-image, and a style-image, and changes the input \n", + "to resemble the content of the content-image and the artistic style of the style-image.\n", + "\n", + " \n", + ".. figure:: /_static/img/neural-style/neuralstyle.png\n", + " :alt: content1\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Underlying Principle\n", + "--------------------\n", + "\n", + "The principle is simple: we define two distances, one for the content\n", + "($D_C$) and one for the style ($D_S$). $D_C$ measures how different the content\n", + "is between two images while $D_S$ measures how different the style is\n", + "between two images. Then, we take a third image, the input, and\n", + "transform it to minimize both its content-distance with the\n", + "content-image and its style-distance with the style-image. Now we can\n", + "import the necessary packages and begin the neural transfer.\n", + "\n", + "Importing Packages and Selecting a Device\n", + "-----------------------------------------\n", + "Below is a list of the packages needed to implement the neural transfer.\n", + "\n", + "- ``torch``, ``torch.nn``, ``numpy`` (indispensables packages for\n", + " neural networks with PyTorch)\n", + "- ``torch.optim`` (efficient gradient descents)\n", + "- ``PIL``, ``PIL.Image``, ``matplotlib.pyplot`` (load and display\n", + " images)\n", + "- ``torchvision.transforms`` (transform PIL images into tensors)\n", + "- ``torchvision.models`` (train or load pre-trained models)\n", + "- ``copy`` (to deep copy the models; system package)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import torchvision.transforms as transforms\n", + "import torchvision.models as models\n", + "\n", + "import copy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we need to choose which device to run the network on and import the\n", + "content and style images. Running the neural transfer algorithm on large\n", + "images takes longer and will go much faster when running on a GPU. We can\n", + "use ``torch.cuda.is_available()`` to detect if there is a GPU available.\n", + "Next, we set the ``torch.device`` for use throughout the tutorial. Also the ``.to(device)``\n", + "method is used to move tensors or modules to a desired device. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Loading the Images\n", + "------------------\n", + "\n", + "Now we will import the style and content images. The original PIL images have values between 0 and 255, but when\n", + "transformed into torch tensors, their values are converted to be between\n", + "0 and 1. The images also need to be resized to have the same dimensions.\n", + "An important detail to note is that neural networks from the\n", + "torch library are trained with tensor values ranging from 0 to 1. If you\n", + "try to feed the networks with 0 to 255 tensor images, then the activated\n", + "feature maps will be unable sense the intended content and style.\n", + "However, pre-trained networks from the Caffe library are trained with 0\n", + "to 255 tensor images. \n", + "\n", + "\n", + ".. Note::\n", + " Here are links to download the images required to run the tutorial:\n", + " `picasso.jpg `__ and\n", + " `dancing.jpg `__.\n", + " Download these two images and add them to a directory\n", + " with name ``images`` in your current working directory.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# desired size of the output image\n", + "imsize = 512 if torch.cuda.is_available() else 128 # use small size if no gpu\n", + "\n", + "loader = transforms.Compose([\n", + " transforms.Resize(imsize), # scale imported image\n", + " transforms.ToTensor()]) # transform it into a torch tensor\n", + "\n", + "\n", + "def image_loader(image_name):\n", + " image = Image.open(image_name)\n", + " # fake batch dimension required to fit network's input dimensions\n", + " image = loader(image).unsqueeze(0)\n", + " return image.to(device, torch.float)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import os\n", + "import os.path\n", + "def convertjpg(jpgfile, savedir, width=250, height=325):\n", + " img = Image.open(jpgfile)\n", + " new_img = img.resize((width,height),Image.ANTIALIAS)\n", + " new_img.save(os.path.join(savedir,os.path.basename(jpgfile)))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "convertjpg(\"./data/images/style/Avatar.jpg\",\"./data/images/style/\")\n", + "convertjpg(\"./data/images/content/Cpy.jpg\",\"./data/images/content/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "style_img = image_loader(\"./data/images/style/Avatar.jpg\")\n", + "content_img = image_loader(\"./data/images/content/Cpy.jpg\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's create a function that displays an image by reconverting a \n", + "copy of it to PIL format and displaying the copy using \n", + "``plt.imshow``. We will try displaying the content and style images \n", + "to ensure they were imported correctly.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "unloader = transforms.ToPILImage() # reconvert into PIL image\n", + "\n", + "plt.ion()\n", + "\n", + "def imshow(tensor, title=None):\n", + " image = tensor.cpu().clone() # we clone the tensor to not do changes on it\n", + " image = image.squeeze(0) # remove the fake batch dimension\n", + " image = unloader(image)\n", + " plt.imshow(image)\n", + " if title is not None:\n", + " plt.title(title)\n", + " plt.pause(0.001) # pause a bit so that plots are updated\n", + "\n", + "\n", + "plt.figure()\n", + "imshow(style_img, title='Style Image')\n", + "\n", + "plt.figure()\n", + "imshow(content_img, title='Content Image')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Loss Functions\n", + "--------------\n", + "Content Loss\n", + "~~~~~~~~~~~~\n", + "\n", + "The content loss is a function that represents a weighted version of the\n", + "content distance for an individual layer. The function takes the feature\n", + "maps $F_{XL}$ of a layer $L$ in a network processing input $X$ and returns the\n", + "weighted content distance $w_{CL}.D_C^L(X,C)$ between the image $X$ and the\n", + "content image $C$. The feature maps of the content image($F_{CL}$) must be\n", + "known by the function in order to calculate the content distance. We\n", + "implement this function as a torch module with a constructor that takes\n", + "$F_{CL}$ as an input. The distance $\\|F_{XL} - F_{CL}\\|^2$ is the mean square error\n", + "between the two sets of feature maps, and can be computed using ``nn.MSELoss``.\n", + "\n", + "We will add this content loss module directly after the convolution\n", + "layer(s) that are being used to compute the content distance. This way\n", + "each time the network is fed an input image the content losses will be\n", + "computed at the desired layers and because of auto grad, all the\n", + "gradients will be computed. Now, in order to make the content loss layer\n", + "transparent we must define a ``forward`` method that computes the content\n", + "loss and then returns the layer’s input. The computed loss is saved as a\n", + "parameter of the module.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "class ContentLoss(nn.Module):\n", + "\n", + " def __init__(self, target,):\n", + " super(ContentLoss, self).__init__()\n", + " # we 'detach' the target content from the tree used\n", + " # to dynamically compute the gradient: this is a stated value,\n", + " # not a variable. Otherwise the forward method of the criterion\n", + " # will throw an error.\n", + " self.target = target.detach()\n", + "\n", + " def forward(self, input):\n", + " self.loss = F.mse_loss(input, self.target)\n", + " return input" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ".. Note::\n", + " **Important detail**: although this module is named ``ContentLoss``, it\n", + " is not a true PyTorch Loss function. If you want to define your content\n", + " loss as a PyTorch Loss function, you have to create a PyTorch autograd function \n", + " to recompute/implement the gradient manually in the ``backward``\n", + " method.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Style Loss\n", + "~~~~~~~~~~\n", + "\n", + "The style loss module is implemented similarly to the content loss\n", + "module. It will act as a transparent layer in a\n", + "network that computes the style loss of that layer. In order to\n", + "calculate the style loss, we need to compute the gram matrix $G_{XL}$. A gram\n", + "matrix is the result of multiplying a given matrix by its transposed\n", + "matrix. In this application the given matrix is a reshaped version of\n", + "the feature maps $F_{XL}$ of a layer $L$. $F_{XL}$ is reshaped to form $\\hat{F}_{XL}$, a $K$\\ x\\ $N$\n", + "matrix, where $K$ is the number of feature maps at layer $L$ and $N$ is the\n", + "length of any vectorized feature map $F_{XL}^k$. For example, the first line\n", + "of $\\hat{F}_{XL}$ corresponds to the first vectorized feature map $F_{XL}^1$.\n", + "\n", + "Finally, the gram matrix must be normalized by dividing each element by\n", + "the total number of elements in the matrix. This normalization is to\n", + "counteract the fact that $\\hat{F}_{XL}$ matrices with a large $N$ dimension yield\n", + "larger values in the Gram matrix. These larger values will cause the\n", + "first layers (before pooling layers) to have a larger impact during the\n", + "gradient descent. Style features tend to be in the deeper layers of the\n", + "network so this normalization step is crucial.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def gram_matrix(input):\n", + " a, b, c, d = input.size() # a=batch size(=1)\n", + " # b=number of feature maps\n", + " # (c,d)=dimensions of a f. map (N=c*d)\n", + "\n", + " features = input.view(a * b, c * d) # resise F_XL into \\hat F_XL\n", + "\n", + " G = torch.mm(features, features.t()) # compute the gram product\n", + "\n", + " # we 'normalize' the values of the gram matrix\n", + " # by dividing by the number of element in each feature maps.\n", + " return G.div(a * b * c * d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now the style loss module looks almost exactly like the content loss\n", + "module. The style distance is also computed using the mean square\n", + "error between $G_{XL}$ and $G_{SL}$.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "class StyleLoss(nn.Module):\n", + "\n", + " def __init__(self, target_feature):\n", + " super(StyleLoss, self).__init__()\n", + " self.target = gram_matrix(target_feature).detach()\n", + "\n", + " def forward(self, input):\n", + " G = gram_matrix(input)\n", + " self.loss = F.mse_loss(G, self.target)\n", + " return input" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Importing the Model\n", + "-------------------\n", + "\n", + "Now we need to import a pre-trained neural network. We will use a 19\n", + "layer VGG network like the one used in the paper.\n", + "\n", + "PyTorch’s implementation of VGG is a module divided into two child\n", + "``Sequential`` modules: ``features`` (containing convolution and pooling layers),\n", + "and ``classifier`` (containing fully connected layers). We will use the\n", + "``features`` module because we need the output of the individual\n", + "convolution layers to measure content and style loss. Some layers have\n", + "different behavior during training than evaluation, so we must set the\n", + "network to evaluation mode using ``.eval()``.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading: \"https://download.pytorch.org/models/vgg19-dcbb9e9d.pth\" to /home/cpy/.cache/torch/checkpoints/vgg19-dcbb9e9d.pth\n", + "100%|██████████| 548M/548M [01:58<00:00, 4.84MB/s] \n" + ] + } + ], + "source": [ + "cnn = models.vgg19(pretrained=True).features.to(device).eval()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Additionally, VGG networks are trained on images with each channel\n", + "normalized by mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].\n", + "We will use them to normalize the image before sending it into the network.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device)\n", + "cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(device)\n", + "\n", + "# create a module to normalize input image so we can easily put it in a\n", + "# nn.Sequential\n", + "class Normalization(nn.Module):\n", + " def __init__(self, mean, std):\n", + " super(Normalization, self).__init__()\n", + " # .view the mean and std to make them [C x 1 x 1] so that they can\n", + " # directly work with image Tensor of shape [B x C x H x W].\n", + " # B is batch size. C is number of channels. H is height and W is width.\n", + " self.mean = torch.tensor(mean).view(-1, 1, 1)\n", + " self.std = torch.tensor(std).view(-1, 1, 1)\n", + "\n", + " def forward(self, img):\n", + " # normalize img\n", + " return (img - self.mean) / self.std" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A ``Sequential`` module contains an ordered list of child modules. For\n", + "instance, ``vgg19.features`` contains a sequence (Conv2d, ReLU, MaxPool2d,\n", + "Conv2d, ReLU…) aligned in the right order of depth. We need to add our\n", + "content loss and style loss layers immediately after the convolution\n", + "layer they are detecting. To do this we must create a new ``Sequential``\n", + "module that has content loss and style loss modules correctly inserted.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# desired depth layers to compute style/content losses :\n", + "content_layers_default = ['conv_4']\n", + "style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']\n", + "\n", + "def get_style_model_and_losses(cnn, normalization_mean, normalization_std,\n", + " style_img, content_img,\n", + " content_layers=content_layers_default,\n", + " style_layers=style_layers_default):\n", + " cnn = copy.deepcopy(cnn)\n", + "\n", + " # normalization module\n", + " normalization = Normalization(normalization_mean, normalization_std).to(device)\n", + "\n", + " # just in order to have an iterable access to or list of content/syle\n", + " # losses\n", + " content_losses = []\n", + " style_losses = []\n", + "\n", + " # assuming that cnn is a nn.Sequential, so we make a new nn.Sequential\n", + " # to put in modules that are supposed to be activated sequentially\n", + " model = nn.Sequential(normalization)\n", + "\n", + " i = 0 # increment every time we see a conv\n", + " for layer in cnn.children():\n", + " if isinstance(layer, nn.Conv2d):\n", + " i += 1\n", + " name = 'conv_{}'.format(i)\n", + " elif isinstance(layer, nn.ReLU):\n", + " name = 'relu_{}'.format(i)\n", + " # The in-place version doesn't play very nicely with the ContentLoss\n", + " # and StyleLoss we insert below. So we replace with out-of-place\n", + " # ones here.\n", + " layer = nn.ReLU(inplace=False)\n", + " elif isinstance(layer, nn.MaxPool2d):\n", + " name = 'pool_{}'.format(i)\n", + " elif isinstance(layer, nn.BatchNorm2d):\n", + " name = 'bn_{}'.format(i)\n", + " else:\n", + " raise RuntimeError('Unrecognized layer: {}'.format(layer.__class__.__name__))\n", + "\n", + " model.add_module(name, layer)\n", + "\n", + " if name in content_layers:\n", + " # add content loss:\n", + " target = model(content_img).detach()\n", + " content_loss = ContentLoss(target)\n", + " model.add_module(\"content_loss_{}\".format(i), content_loss)\n", + " content_losses.append(content_loss)\n", + "\n", + " if name in style_layers:\n", + " # add style loss:\n", + " target_feature = model(style_img).detach()\n", + " style_loss = StyleLoss(target_feature)\n", + " model.add_module(\"style_loss_{}\".format(i), style_loss)\n", + " style_losses.append(style_loss)\n", + "\n", + " # now we trim off the layers after the last content and style losses\n", + " for i in range(len(model) - 1, -1, -1):\n", + " if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss):\n", + " break\n", + "\n", + " model = model[:(i + 1)]\n", + "\n", + " return model, style_losses, content_losses" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we select the input image. You can use a copy of the content image\n", + "or white noise.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "input_img = content_img.clone()\n", + "# if you want to use white noise instead uncomment the below line:\n", + "# input_img = torch.randn(content_img.data.size(), device=device)\n", + "\n", + "# add the original input image to the figure:\n", + "plt.figure()\n", + "imshow(input_img, title='Input Image')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gradient Descent\n", + "----------------\n", + "\n", + "As Leon Gatys, the author of the algorithm, suggested `here `__, we will use\n", + "L-BFGS algorithm to run our gradient descent. Unlike training a network,\n", + "we want to train the input image in order to minimise the content/style\n", + "losses. We will create a PyTorch L-BFGS optimizer ``optim.LBFGS`` and pass\n", + "our image to it as the tensor to optimize.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def get_input_optimizer(input_img):\n", + " # this line to show that input is a parameter that requires a gradient\n", + " optimizer = optim.LBFGS([input_img.requires_grad_()])\n", + " return optimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we must define a function that performs the neural transfer. For\n", + "each iteration of the networks, it is fed an updated input and computes\n", + "new losses. We will run the ``backward`` methods of each loss module to\n", + "dynamicaly compute their gradients. The optimizer requires a “closure”\n", + "function, which reevaluates the modul and returns the loss.\n", + "\n", + "We still have one final constraint to address. The network may try to\n", + "optimize the input with values that exceed the 0 to 1 tensor range for\n", + "the image. We can address this by correcting the input values to be\n", + "between 0 to 1 each time the network is run.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "def run_style_transfer(cnn, normalization_mean, normalization_std,\n", + " content_img, style_img, input_img, num_steps=500,\n", + " style_weight=1000000, content_weight=1):\n", + " \"\"\"Run the style transfer.\"\"\"\n", + " print('Building the style transfer model..')\n", + " model, style_losses, content_losses = get_style_model_and_losses(cnn,\n", + " normalization_mean, normalization_std, style_img, content_img)\n", + " optimizer = get_input_optimizer(input_img)\n", + "\n", + " print('Optimizing..')\n", + " run = [0]\n", + " while run[0] <= num_steps:\n", + "\n", + " def closure():\n", + " # correct the values of updated input image\n", + " input_img.data.clamp_(0, 1)\n", + "\n", + " optimizer.zero_grad()\n", + " model(input_img)\n", + " style_score = 0\n", + " content_score = 0\n", + "\n", + " for sl in style_losses:\n", + " style_score += sl.loss\n", + " for cl in content_losses:\n", + " content_score += cl.loss\n", + "\n", + " style_score *= style_weight\n", + " content_score *= content_weight\n", + "\n", + " loss = style_score + content_score\n", + " loss.backward()\n", + "\n", + " run[0] += 1\n", + " if run[0] % 50 == 0:\n", + " print(\"run {}:\".format(run))\n", + " print('Style Loss : {:4f} Content Loss: {:4f}'.format(\n", + " style_score.item(), content_score.item()))\n", + " print()\n", + "\n", + " return style_score + content_score\n", + "\n", + " optimizer.step(closure)\n", + "\n", + " # a last correction...\n", + " input_img.data.clamp_(0, 1)\n", + "\n", + " return input_img" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can run the algorithm.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building the style transfer model..\n", + "Optimizing..\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/cpy/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " if sys.path[0] == '':\n", + "/home/cpy/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " del sys.path[0]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "run [50]:\n", + "Style Loss : 174.907303 Content Loss: 6.201799\n", + "\n", + "run [100]:\n", + "Style Loss : 62.956490 Content Loss: 7.132496\n", + "\n", + "run [150]:\n", + "Style Loss : 29.948500 Content Loss: 7.028089\n", + "\n", + "run [200]:\n", + "Style Loss : 17.228781 Content Loss: 6.452642\n", + "\n", + "run [250]:\n", + "Style Loss : 10.021835 Content Loss: 5.934164\n", + "\n", + "run [300]:\n", + "Style Loss : 6.096354 Content Loss: 5.521115\n", + "\n", + "run [350]:\n", + "Style Loss : 4.328116 Content Loss: 5.142741\n", + "\n", + "run [400]:\n", + "Style Loss : 3.409873 Content Loss: 4.896431\n", + "\n", + "run [450]:\n", + "Style Loss : 2.787455 Content Loss: 4.679248\n", + "\n", + "run [500]:\n", + "Style Loss : 2.291887 Content Loss: 4.531116\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "output = run_style_transfer(cnn, cnn_normalization_mean, cnn_normalization_std,\n", + " content_img, style_img, input_img)\n", + "\n", + "plt.figure()\n", + "imshow(output, title='Output Image')\n", + "\n", + "# sphinx_gallery_thumbnail_number = 4\n", + "plt.ioff()\n", + "plt.show()" + ] + } + ], + "metadata": { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}