{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Demo for integrating robust GD into neural net backprop\n", "\n", "This is the main notebook for the companion repository to our tutorial paper Robust gradient descent via back-propagation: A Chainer-based tutorial.\n", "\n", "#### Contents:\n", "\n", "1. Implementing our first example\n", "\n", "1. A complete demo: Iris data with noisy inputs\n", "\n", " 1. Prepare the data set\n", " \n", " 1. Try out the learning algorithm(s)\n", " \n", " 1. Visualization of learning efficiency" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "___" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Implementing our first example" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import chainer.computational_graph as cg\n", "import chainer.functions as cfn\n", "import chainer as ch\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Step by step forward computations.\n", "x1 = ch.Variable(np.array([1.5], dtype=np.float32))\n", "x2 = ch.Variable(np.array([3.0], dtype=np.float32))\n", "u1 = x1**3\n", "u2 = x1*x2\n", "u3 = u1/x2\n", "u4 = cfn.sin(u2)\n", "u5 = u3+u4" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "g = cg.build_computational_graph([u5])\n", "with open(\"simple_ex_cpgraph.dot\", \"w\") as o:\n", " o.write(g.dump())" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "! dot -Tpdf simple_ex_cpgraph.dot -o simple_ex_cpgraph.pdf\n", "! dot -Tpng simple_ex_cpgraph.dot -o simple_ex_cpgraph.png" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See the computational graph below (refresh browser if required):\n", "\n", " \"computational\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compute $\\bar{u}_{i}$ and $\\bar{x}_{i}$ quantities manually:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Reverse mode computations (by hand)\n", "ub5 = ch.Variable(np.array([1.0], dtype=np.float32))\n", "ub4 = ub5\n", "ub3 = ub5\n", "ub2 = ub4*cfn.cos(u2)\n", "ub1 = ub3/x2\n", "xb2 = -ub3*u1/x2**2 + ub2*x1\n", "xb1 = ub2*x2 + ub1*3*x1**2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now use Chainer to compute the same quantities automatically:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Reverse mode computations (by Chainer)\n", "u5.backward(retain_grad=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, compare the outputs:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ub5 = 1.0000 vs. u5.grad = 1.0000\n", "ub4 = 1.0000 vs. u4.grad = 1.0000\n", "ub3 = 1.0000 vs. u3.grad = 1.0000\n", "ub2 = -0.2108 vs. u2.grad = -0.2108\n", "ub1 = 0.3333 vs. u1.grad = 0.3333\n", "xb2 = -0.6912 vs. x2.grad = -0.6912\n", "xb1 = 1.6176 vs. x1.grad = 1.6176\n" ] } ], "source": [ "print(\"ub5 = {:5.4f} vs. u5.grad = {:5.4f}\".format(ub5.data[0],u5.grad[0]))\n", "print(\"ub4 = {:5.4f} vs. u4.grad = {:5.4f}\".format(ub4.data[0],u4.grad[0]))\n", "print(\"ub3 = {:5.4f} vs. u3.grad = {:5.4f}\".format(ub3.data[0],u3.grad[0]))\n", "print(\"ub2 = {:5.4f} vs. u2.grad = {:5.4f}\".format(ub2.data[0],u2.grad[0]))\n", "print(\"ub1 = {:5.4f} vs. u1.grad = {:5.4f}\".format(ub1.data[0],u1.grad[0]))\n", "print(\"xb2 = {:5.4f} vs. x2.grad = {:5.4f}\".format(xb2.data[0],x2.grad[0]))\n", "print(\"xb1 = {:5.4f} vs. x1.grad = {:5.4f}\".format(xb1.data[0],x1.grad[0]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "___" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## A complete demo: Iris data with noisy inputs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Prepare the data set\n", "\n", "First we acquire the famous Iris Data Set due to R.A. Fisher, included in the UCI Machine Learning Respository. We shall store the data in a directory called `data`." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "! mkdir -p data\n", "! mkdir -p data/iris" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--2019-04-09 09:33:08-- https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data\n", "Resolving archive.ics.uci.edu (archive.ics.uci.edu)... 128.195.10.252\n", "Connecting to archive.ics.uci.edu (archive.ics.uci.edu)|128.195.10.252|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 4551 (4.4K) [application/x-httpd-php]\n", "Saving to: ‘data/iris/iris.data’\n", "\n", "iris.data 100%[===================>] 4.44K --.-KB/s in 0s \n", "\n", "2019-04-09 09:33:08 (48.4 MB/s) - ‘data/iris/iris.data’ saved [4551/4551]\n", "\n", "--2019-04-09 09:33:08-- https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names\n", "Resolving archive.ics.uci.edu (archive.ics.uci.edu)... 128.195.10.252\n", "Connecting to archive.ics.uci.edu (archive.ics.uci.edu)|128.195.10.252|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 2998 (2.9K) [application/x-httpd-php]\n", "Saving to: ‘data/iris/iris.names’\n", "\n", "iris.names 100%[===================>] 2.93K --.-KB/s in 0s \n", "\n", "2019-04-09 09:33:09 (56.0 MB/s) - ‘data/iris/iris.names’ saved [2998/2998]\n", "\n" ] } ], "source": [ "! wget -nc https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data -P data/iris/\n", "! wget -nc https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names -P data/iris/" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next we organize a few basic facts about the dataset, chiefly for clerical purposes." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Clerical stuff.\n", "_n = 150\n", "_n_tr = 100\n", "_n_te = _n - _n_tr\n", "_nf = 4 # number of features to start.\n", "_nc = 3 # number of classes.\n", "_label_dict = {\"Iris-setosa\": 0,\n", " \"Iris-versicolor\": 1,\n", " \"Iris-virginica\": 2}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Beware that this `iris.data` file contains one more line than is required (since there should be only 150 points). The 151st line is blank, and so we can just skip it." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "151 data/iris/iris.data\r\n" ] } ], "source": [ "! wc -l data/iris/iris.data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next we use the `csv` module to read the text file and convert the data into a `numpy` array." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "import os\n", "import csv\n", "import numpy as np\n", "from sklearn.decomposition import PCA\n", "\n", "toread = os.path.join(\"data\", \"iris\", \"iris.data\")\n", "\n", "X = np.zeros((_n,_nf), dtype=np.float32)\n", "y = np.zeros((_n,1), dtype=np.int8)\n", "\n", "with open(toread, newline=\"\") as f_table:\n", " \n", " f_reader = csv.reader(f_table, delimiter=\",\")\n", " \n", " i = 0\n", " for line in f_reader:\n", " X[i,:] = np.array(line[0:-1],\n", " dtype=X.dtype)\n", " y[i,:] = np.array(_label_dict[line[-1]],\n", " dtype=y.dtype)\n", " i += 1\n", " \n", " if i >= _n: # to skip the final blank line.\n", " break\n", " " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# Shuffle up the data set (+ PCA dim reduction).\n", "my_pca = PCA(n_components=2, whiten=True) # PCA setup.\n", "shufidx = np.random.choice(X.shape[0], size=X.shape[0], replace=False)\n", "X = my_pca.fit_transform(X[shufidx,:]) # PCA mapping.\n", "y = y[shufidx,:]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Normalize the inputs in a per-feature manner (as max/min are vecs).\n", "maxvec = np.max(X, axis=0)\n", "minvec = np.min(X, axis=0)\n", "X = X-minvec\n", "with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n", " X = X / (maxvec-minvec)\n", " X[X == np.inf] = 0\n", " X = np.nan_to_num(X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This ends our preparation of the dimension-reduced dataset; random perturbations to the inputs will be done at runtime." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Try out the learning algorithm(s)\n", "\n", "Let us call the demonstration experiment here `iris_noisyinputs`. We make a directory for saving results." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "import math\n", "import chainer as ch\n", "import get_model as gm\n", "import helpers as hlp\n", "import robustify as rob\n", "\n", "# Prepare a results directory.\n", "_task_name = \"iris_noisyinputs\"\n", "towrite = os.path.join(\"results\", _task_name)\n", "hlp.makedir_safe(dirname=towrite)\n", "\n", "# Data modification parameters.\n", "_rad_factor = 1e+4 # coefficient controlling how far to push data.\n", "_frac_to_move = 0.02 # the fraction of the training data to perturb." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# Model/algorithm parameters.\n", "_num_trials = 20\n", "_t_max = 1000\n", "_num_records = 1000+1 # number of times to record performance.\n", "_lr = 0.5 # learning rate for steepest descent type of update.\n", "_num_units = 10 # number of units in each hidden layer.\n", "_robfn = rob.softmean # specification of robustifier.\n", "_todiv = _t_max // (_num_records-1)\n", "_mod_names = [\"deep\", \"deep-rob\"]\n", "_paras = {\"num_units\": _num_units,\n", " \"robfn\": _robfn}" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Working on deep...\n", "Trial number 0.\n", "Trial number 10.\n", "Done.\n", "Working on deep-rob...\n", "Trial number 0.\n", "Trial number 10.\n", "Done.\n" ] } ], "source": [ "# Main loop over methods.\n", "\n", "for mod_name in _mod_names:\n", " \n", " print(\"Working on {}...\".format(mod_name))\n", " \n", " # Prepare storage for performance metrics.\n", " loss_tr = np.zeros((_num_trials,_num_records), dtype=np.float32)\n", " loss_te = np.zeros((_num_trials,_num_records), dtype=np.float32)\n", " costs = np.zeros((_num_records,), dtype=np.uint32)\n", " \n", " for tri in range(_num_trials):\n", " \n", " if tri % 10 == 0:\n", " print(\"Trial number {}.\".format(tri))\n", " \n", " cost_counter = 0\n", " \n", " shufidx = np.random.choice(_n, size=_n, replace=False)\n", " X_tr = X[shufidx[0:_n_tr],:]\n", " y_tr = y[shufidx[0:_n_tr],:]\n", " X_te = X[shufidx[_n_tr:],:]\n", " y_te = y[shufidx[_n_tr:],:]\n", " \n", " # Add input noise randomly.\n", " x_center = np.mean(X_tr, axis=0)\n", " x_sd = np.std(\n", " np.sqrt(np.sum((X_tr-x_center)**2, axis=1))\n", " )\n", " idx_to_move = np.random.choice(_n_tr,\n", " size=math.ceil(_frac_to_move*_n_tr),\n", " replace=False)\n", " r_noise = _rad_factor * x_sd\n", " for i in idx_to_move:\n", " x_pre = X_tr[i,:]\n", " r_ratio = r_noise / np.sqrt(np.sum((x_pre-x_center)**2))\n", " X_tr[i,:] = -x_pre*r_ratio + (1+r_ratio)*x_center\n", " \n", " # Preparation of model and optimizer objects.\n", " mod = gm.get_model(mod_name=mod_name,\n", " nf=X.shape[1], nc=_nc,\n", " paras=_paras)\n", " opt = ch.optimizers.SGD(lr=_lr)\n", " opt.setup(mod)\n", " \n", " # Finally, run the learning algorithm for the initialized models.\n", " tval = 0\n", " idx = 0\n", " while tval < _t_max:\n", "\n", " # Evaluate current state.\n", " loss = ch.functions.softmax_cross_entropy(\n", " x=mod(X_tr),\n", " t=y_tr.flatten(),\n", " normalize=True,\n", " reduce=\"mean\"\n", " )\n", "\n", " # Get gradients.\n", " mod.cleargrads()\n", " loss.backward()\n", "\n", " # Parameter update.\n", " opt.update()\n", "\n", " # Cost update (assumes gradient descent using full batch).\n", " if tri == 0:\n", " cost_counter += X_tr.shape[0]\n", "\n", " # Record performance for the given iteration.\n", " if tval % _todiv == 0:\n", " \n", " if tri == 0:\n", " costs[idx] = cost_counter\n", " \n", " acc_tr = ch.functions.accuracy(y=mod(X_tr),\n", " t=y_tr.flatten()).data\n", " acc_te = ch.functions.accuracy(y=mod(X_te),\n", " t=y_te.flatten()).data\n", " loss_tr[tri,idx] = 1.0-acc_tr\n", " loss_te[tri,idx] = 1.0-acc_te\n", " \n", " idx += 1\n", "\n", " tval += 1\n", " \n", " # Record final performance if not done so already.\n", " if idx < _num_records:\n", " \n", " if tri == 0:\n", " costs[idx] = cost_counter\n", " \n", " acc_tr = ch.functions.accuracy(y=mod(X_tr),\n", " t=y_tr.flatten()).data\n", " acc_te = ch.functions.accuracy(y=mod(X_te),\n", " t=y_te.flatten()).data\n", " loss_tr[tri,idx] = 1.0-acc_tr\n", " loss_te[tri,idx] = 1.0-acc_te\n", " \n", " idx += 1\n", " \n", " # After running all trials, take stats and arrange into perf mtx.\n", " ave_loss_tr = np.mean(loss_tr, axis=0)\n", " ave_loss_te = np.mean(loss_te, axis=0)\n", " ave_loss = np.vstack((ave_loss_tr,ave_loss_te)).T # transpose it.\n", "\n", " # Write to disk.\n", " np.savetxt(fname=os.path.join(towrite, (mod_name+\".ave\")),\n", " X=ave_loss, fmt=\"%.7e\", delimiter=\",\")\n", " np.savetxt(fname=os.path.join(towrite, (mod_name+\".cost\")),\n", " X=costs, fmt=\"%d\", delimiter=\",\")\n", " \n", " del mod, opt\n", " \n", " print(\"Done.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Visualization of learning efficiency" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import os\n", "import matplotlib.pyplot as plt\n", "\n", "_fontsize = \"xx-large\"\n", "_task_name = \"iris_noisyinputs\"\n", "_mth_names = [\"deep\", \"deep-rob\"]\n", "_mth_colors = [\"black\", \"blue\"]\n", "_mth_markers = [\"-\", \"-\"]" ] }, { "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" } ], "source": [ "myfig = plt.figure(figsize=(12,6))\n", "\n", "perf_idx = 0\n", "ax1 = myfig.add_subplot(1,2,1)\n", "for i in range(len(_mth_names)):\n", " \n", " mth_name = _mth_names[i]\n", " mth_color = _mth_colors[i]\n", " \n", " toread = os.path.join(\"results\", _task_name)\n", " \n", " # Read in all relevant performance.\n", " with open(os.path.join(toread, (mth_name+\".ave\")), mode=\"r\", encoding=\"ascii\") as f:\n", " tmp_ave = np.loadtxt(fname=f, dtype=np.float, usecols=perf_idx, delimiter=\",\")\n", " \n", " with open(os.path.join(toread, (mth_name+\".cost\")), mode=\"r\", encoding=\"ascii\") as f:\n", " tmp_cost = np.loadtxt(fname=f, dtype=np.uint, delimiter=\",\")\n", " \n", " ax1.plot(tmp_cost, tmp_ave, _mth_markers[i],\n", " color=mth_color,\n", " label=mth_name) # option: semilogy with basey=10.\n", " ax1.tick_params(labelsize=_fontsize)\n", "\n", "ax1.legend(loc=\"best\",ncol=1, fontsize=_fontsize)\n", "plt.title(\"Misclass rate (train)\", size=_fontsize)\n", "plt.xlabel(\"Cost in gradients\", size=_fontsize)\n", "\n", "perf_idx = 1\n", "ax2 = myfig.add_subplot(1,2,2, sharey=ax1)\n", "for i in range(len(_mth_names)):\n", " \n", " mth_name = _mth_names[i]\n", " mth_color = _mth_colors[i]\n", " \n", " #print(\"Performance evaluation:\", mth_name)\n", " \n", " toread = os.path.join(\"results\", _task_name)\n", " \n", " # Read in all relevant performance.\n", " with open(os.path.join(toread, (mth_name+\".ave\")), mode=\"r\", encoding=\"ascii\") as f:\n", " tmp_ave = np.loadtxt(fname=f, dtype=np.float, usecols=perf_idx, delimiter=\",\")\n", " \n", " with open(os.path.join(toread, (mth_name+\".cost\")), mode=\"r\", encoding=\"ascii\") as f:\n", " tmp_cost = np.loadtxt(fname=f, dtype=np.uint, delimiter=\",\")\n", " \n", " ax2.plot(tmp_cost, tmp_ave, _mth_markers[i],\n", " color=mth_color,\n", " label=mth_name)# option: semilogy with basey=10.\n", " ax2.tick_params(labelsize=_fontsize)\n", "\n", "plt.title(\"Misclass rate (test)\", size=_fontsize)\n", "plt.xlabel(\"Cost in gradients\", size=_fontsize)\n", "\n", "plt.savefig(fname=\"results_iris_noisyinputs.pdf\", bbox_inches=\"tight\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "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.6.8" } }, "nbformat": 4, "nbformat_minor": 2 }