{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# SVRG and numerical tests\n", "\n", "Our main task in this notebook, using the tools we have developed thus far in previous notebooks, is to implement the stochastic variance reduced gradient (SVRG) descent technique of Johnson and Zhang proposed in their paper *Accelerating Stochastic Gradient Descent using Predictive Variance Reduction* (NIPS 2013, link), and re-create their numerical experiments.\n", "\n", "__Contents:__\n", "\n", "- Formulation of algorithm\n", "\n", "- SVRG implementation\n", "\n", " - General-purpose SVRG\n", " \n", " - SVRG for Chainer\n", "\n", "- Overview of numerical experiments\n", "\n", "- Testing and empirical analysis\n", "\n", " - Running linear models (\"convex\" case)\n", " - Running non-linear models (\"non-convex\" case)\n", " - Evaluation of performance\n", "\n", "___" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Formulation of algorithm\n", "\n", "The problem setting considered by the SVRG algorithm is as follows.\n", "\n", "The objective is minimization of a sum of real-valued functions with domain $\\mathbb{R}^d$. Using our loss function notation, this is\n", "\n", "\\begin{align*}\n", "\\min_{w \\in \\mathbb{R}^{d}} F(w), \\quad F(w) = \\frac{1}{n} \\sum_{i=1}^{n} L(w;z_{i}).\n", "\\end{align*}\n", "\n", "Stochastic gradient descent (SGD), as introduced previously, is a popular technique for solving this minimization task. SGD offers a low-cost approach to exploring parameter space while on average moving in the direction of a traditional (expensive) full-batch gradient descent update.\n", "\n", "On the other hand, since SGD uses only one or very few examples per iteration, the algorithm does not tend to converge unless the step size $\\alpha_{(t)} \\to 0$ as $t \\to \\infty$. SGD does not converge on its own because of the sub-sampling induced variance. Strictly speaking, when we run SGD, we are running a single full-batch GD update for a different objective function at each step, pulling the parameter vector in different directions *ad infinitum*.\n", "\n", "The basic idea of the authors is to propose a compromise:\n", "\n", "- For the vast majority of iterations, compute gradients for a mini-batch of size $B \\ll n$.\n", "- For a small fraction of iterations, compute a full-batch gradient (size $n$), and use that valuable information to stabilize subsequent updates.\n", "\n", "Their idea for stabilization is extremely simple, and it often works very well in practice. Let's get into the details." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The procedure takes a two-loop structure as follows. Initialize $\\tilde{w}_{0}$. This is a \"snapshot\" vector that will be used as a reference in the inner loop. In the outer loop, we do full-batch computations. For each $s = 1,2,\\ldots$, do the following:\n", "\n", "0. $\\tilde{w} = \\tilde{w}_{(s-1)}$\n", "\n", "0. $\\displaystyle \\tilde{g} = \\frac{1}{n} \\sum_{i=1}^{n} \\nabla L(\\tilde{w};z_{i})$\n", "\n", "0. $w_{(0)} = \\tilde{w}$\n", "\n", "0. Run inner loop for $T$ steps, get $w_{(T)}$\n", "\n", "0. Set $\\tilde{w}_{s} = w_{(T)}$.\n", "\n", "The core computation here is $\\tilde{g}$. Given the finite-sum objective, this is the ideal update direction at $\\tilde{w}$. The $w_{(0)}$ is simply an initialization for the inner loop. With this done, the procedure enters an inner loop. For each $t=0,1,\\ldots,T$ do the following:\n", "\n", "0. Randomly choose $I_{t} \\in \\{1,\\ldots,n\\}$\n", "0. $\\Delta_{t} = \\nabla L(\\tilde{w};z_{I_{t}}) - \\tilde{g}$\n", "0. Update as $\\displaystyle w_{(t+1)} = w_{(t)} - \\alpha \\left(\\nabla L(w_{(t)};z_{I_{t}}) - \\Delta_{t} \\right)$\n", "\n", "This strategy is really very elegant in its simplicity and direct nature; $\\Delta_{t}$ represents how far off the single-example estimator is from the desired update direction, for the \"snapshot\" $\\tilde{w}$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The core underlying assumption is that as long as the snapshot is updated relatively frequently, the deviation of the mini-batch estimator at $\\tilde{w}$ will be similar to its deviation at $w_{(t)}$, for all steps in the inner loop.\n", "\n", "Note also that, just as with SGD, when we condition on $w_{(t)}$, taking expectation with respect to the random choice of $I_{t}$, we have\n", "\n", "\\begin{align*}\n", "\\mathbf{E} \\left( \\nabla L(w_{(t)};z_{I_{t}}) - \\Delta_{t} \\right) & = \\frac{1}{n} \\sum_{i=1}^{n} L(w_{(t)};z_{i}) - \\mathbf{E} \\left( \\nabla L(\\tilde{w};z_{I_{t}}) - \\tilde{g}\\right)\\\\\n", "& = \\frac{1}{n} \\sum_{i=1}^{n} L(w_{(t)};z_{i}).\n", "\\end{align*}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## SVRG implementation\n", "\n", "Here we shall provide two implementations of SVRG. One will continue in the tradition of our previous hand-built algorithms with Algo_SVRG, defined as a sub-class of Algo_LineSearch. The other will be an implementation adapted to neural network models developed using Chainer." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import math\n", "import numpy as np\n", "import chainer as ch\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "import algorithms\n", "import models\n", "import models_ch\n", "import dataclass\n", "import helpers as hlp" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### General-purpose SVRG" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "class Algo_SVRG(algorithms.Algo_LineSearch):\n", " '''\n", " Stochastic variance reduced gradient descent.\n", " '''\n", " def __init__(self, w_init, step, batchsize, replace,\n", " out_max, in_max, thres, store, lamreg):\n", "\n", " super(Algo_SVRG, self).__init__(w_init=w_init,\n", " step=step,\n", " t_max=(out_max*in_max),\n", " thres=thres,\n", " store=store,\n", " lamreg=lamreg)\n", " self.out_max = out_max\n", " self.in_max = in_max\n", " self.batchsize = batchsize\n", " self.replace = replace\n", "\n", " # Computed internally.\n", " self.nseen = 0\n", " self.npasses = 0\n", " self.idx_inner = 0\n", " self.torecord = True\n", "\n", "\n", " def newdir(self, model, data):\n", " '''\n", " Determine the direction of the update.\n", " '''\n", "\n", " if self.idx_inner == 0:\n", " self.w_snap = np.copy(self.w)\n", " self.g_snap = np.mean(model.g_tr(w=self.w_snap,\n", " data=data,\n", " lamreg=self.lamreg),\n", " axis=0, keepdims=True)\n", " \n", " shufidx = np.random.choice(data.n_tr,\n", " size=self.batchsize,\n", " replace=self.replace)\n", " g_sgd = np.mean(model.g_tr(w=self.w,\n", " n_idx=shufidx,\n", " data=data,\n", " lamreg=self.lamreg),\n", " axis=0, keepdims=True)\n", " correction = np.mean(model.g_tr(w=self.w_snap,\n", " n_idx=shufidx,\n", " data=data,\n", " lamreg=self.lamreg),\n", " axis=0, keepdims=True) - self.g_snap\n", " return (-1) * (g_sgd-correction)\n", "\n", "\n", " def monitor_update(self, model, data):\n", " '''\n", " Update the counters and convergence\n", " monitors used by the algorithm. This is\n", " executed once every step.\n", " '''\n", " self.t += 1\n", " self.idx_inner += 1\n", " if self.idx_inner == self.in_max:\n", " self.idx_inner = 0\n", "\n", " # Check differences every \"epoch\" over data.\n", " self.nseen += self.batchsize\n", " if self.nseen >= data.n_tr:\n", " self.torecord = True\n", " self.npasses += 1\n", " self.diff = np.linalg.norm((self.w-self.w_old))\n", " self.w_old = np.copy(self.w)\n", " self.nseen = self.nseen % data.n_tr\n", " \n", " \n", " def cost_update(self, model, data):\n", " '''\n", " Update the amount of computational resources\n", " used by the routine.\n", "\n", " Cost computation based on number of gradients computed:\n", " - Each inner loop step requires mini-batch gradients for\n", " two vectors, w and w_snap.\n", " - Each outer loop step additionally requires a full\n", " batch of gradients.\n", " '''\n", "\n", " if self.idx_inner == self.in_max:\n", " self.stepcost = 2 * self.batchsize + data.n_tr\n", " else:\n", " self.stepcost = 2 * self.batchsize\n", " \n", " self.cumcost += self.stepcost\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### SVRG for Chainer\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "## Experiment setup.\n", "\n", "# Data-related.\n", "data = dataclass.DataSet() # Initialize one data object; will be re-populated at each trial.\n", "n = 500 # sample size\n", "d = 2 # number of parameters\n", "init_delta = 5.0 # controls support of random initialization\n", "num_trials = 250 # number of independent random trials to conduct\n", "cov_X = np.eye(d) # covariance matrix of the inputs.\n", "\n", "w_star = np.ones(d).reshape((d,1)) # vector specifying true model\n", "\n", "# Algorithm-related.\n", "m_idx_todo = [0,1] # let's us manually pick and choose which methods to evaluate.\n", "out_max = 5\n", "batchsize = 1\n", "in_max = 50\n", "t_max = out_max*in_max # termination condition; maximum number of iterations.\n", "thres = -1.0 # termination condition; if negative, runs for max iterations.\n", "\n", "def alpha_fixed(t, val): # step-size callback function.\n", " return val\n", "def make_step(u):\n", " def mystep(t, model=None, data=None, newdir=None):\n", " return alpha_fixed(t=t, val=u)\n", " return mystep\n", "alphaval = 0.05\n", "\n", "# Clerical.\n", "mth_names = [\"svrg\", \"svrg-ch\"]\n", "num_mths = len(mth_names)\n", "mth_colours = [\"black\", \"blue\"]" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Make choice of additive noise distribution (un-comment your choice).\n", "#paras = {\"name\": \"norm\", \"shift\": 0.0, \"scale\": 20.0}\n", "paras = {\"name\": \"lnorm\", \"meanlog\": 0.0, \"sdlog\": 1.75}\n", "\n", "# Put together risk function.\n", "def risk(w):\n", " mean_noise, var_noise = hlp.noise_risk(paras=paras)\n", " return hlp.riskMaker(w=w, A=cov_X, b=math.sqrt(var_noise), w_star=w_star)\n", "risk_star = risk(w=w_star) # optimal risk value." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "## Running the algorithms.\n", "\n", "# Prepare storage for performance metrics.\n", "riskvals = np.zeros((num_trials,t_max,num_mths), dtype=np.float32)\n", "loss_tr = np.zeros((num_trials,t_max,num_mths), dtype=np.float32)\n", "truedist = np.zeros((num_trials,t_max,num_mths), dtype=np.float32)\n", "\n", "# Loop over trials.\n", "for tri in range(num_trials):\n", " \n", " # Generate new data (with *centered* noise).\n", " X = np.random.normal(loc=0.0, scale=1.0, size=(n,d))\n", " noise = hlp.noise_data(n=n, paras=paras)\n", " y = np.dot(X, w_star) + noise\n", " data.init_tr(X=X, y=y)\n", " \n", " # Data for Chainer model.\n", " Z = ch.datasets.TupleDataset(np.float32(X),\n", " np.float32(y))\n", " \n", " # Initial weight settings.\n", " w_init = w_star + np.random.uniform(low=-init_delta, high=init_delta, size=d).reshape((d,1))\n", " w_init = np.float32(w_init)\n", " \n", " # Initialize models (hand-built).\n", " mod_learner = models.LinearL2(data=data)\n", " risk_star = risk(w=w_star) # optimal risk value.\n", " loss_star = np.mean(mod_learner.l_tr(w=w_star, data=data))\n", " \n", " # Initialize models (Chainer-based).\n", " mod_chainer = models_ch.MyChain(out_l0=d,\n", " out_l1=1,\n", " init_W=w_init.T,\n", " init_b=None,\n", " init_delta=init_delta,\n", " nobias=True)\n", " \n", " mod_snap = models_ch.MyChain(out_l0=d,\n", " out_l1=1,\n", " init_W=w_init.T,\n", " init_b=None,\n", " init_delta=init_delta,\n", " nobias=True)\n", " \n", " # Initialize algorithms (hand-built).\n", " al_svrg = Algo_SVRG(w_init=w_init,\n", " step=make_step(alphaval),\n", " batchsize=batchsize,\n", " replace=False,\n", " out_max=out_max,\n", " in_max=in_max,\n", " thres=thres,\n", " store=True,\n", " lamreg=None)\n", " \n", " \n", " # Run all algorithms and save their performance.\n", " \n", " ## ERM-SVRG.\n", " mthidx = 0\n", " if mthidx in m_idx_todo: \n", " idx = 0\n", " for onestep in al_svrg:\n", " al_svrg.update(model=mod_learner, data=data)\n", " # Record performance\n", " loss_tr[tri,idx,mthidx] = np.mean(mod_learner.l_tr(w=al_svrg.w, data=data))-loss_star\n", " riskvals[tri,idx,mthidx] = risk(w=al_svrg.w)-risk_star\n", " truedist[tri,idx,mthidx] = np.linalg.norm(w_star-al_svrg.w)-0\n", " idx += 1\n", " \n", " ## Replication of ERM-SVRG using Chainer.\n", " mthidx = 1\n", " if mthidx in m_idx_todo:\n", " idx = 0\n", " t = 0\n", " iter_train = ch.iterators.SerialIterator(dataset=Z,\n", " batch_size=batchsize,\n", " repeat=True,\n", " shuffle=False)\n", " while t < t_max:\n", " \n", " # If condition holds, run \"outer loop\" update.\n", " if t % in_max == 0:\n", " \n", " # Use the output of \"inner loop\" as new snapshot.\n", " mod_snap = mod_chainer.copy(mode=\"copy\")\n", " \n", " # Use the full data set here.\n", " X_batch, y_batch = ch.dataset.concat_examples(Z)\n", " prediction_tr_snap = mod_snap(X_batch)\n", " \n", " # Compute loss and full-batch gradient.\n", " loss_snap = ch.functions.mean_squared_error(prediction_tr_snap, y_batch) / 2.0\n", " mod_snap.cleargrads()\n", " loss_snap.backward()\n", " \n", " # Store the gradient list for use in inner loop.\n", " grad_list = [np.copy(p.grad) for p in mod_snap.params()]\n", " \n", " \n", " # Mini-batch computations for inner loop.\n", " Z_batch = iter_train.next()\n", " X_batch, y_batch = ch.dataset.concat_examples(Z_batch)\n", " t += 1 # manage steps ourselves.\n", " \n", " # Predictions.\n", " prediction_tr = mod_chainer(X_batch)\n", " prediction_tr_snap = mod_snap(X_batch)\n", "\n", " # Loss computations (will feed the grad computations).\n", " loss = ch.functions.mean_squared_error(prediction_tr, y_batch) / 2.0\n", " loss_snap = ch.functions.mean_squared_error(prediction_tr_snap, y_batch) / 2.0\n", " #old_loss = np.mean(mod_learner.l_tr(w=mod_chainer.l1.W.data.T, data=data))\n", " \n", " # Gradient computations.\n", " mod_chainer.cleargrads()\n", " mod_snap.cleargrads()\n", " loss.backward()\n", " loss_snap.backward()\n", " \n", " # Parameter updates.\n", " zipped = zip(mod_chainer.params(), mod_snap.params(), grad_list)\n", " for p, p_snap, mu in zipped:\n", " grad = p.grad\n", " grad_snap = p_snap.grad\n", " if grad is None:\n", " continue\n", " else:\n", " adjust = grad_snap - mu\n", " p.data -= alphaval * (grad-adjust)\n", "\n", " # Record performance\n", " loss_tr[tri,idx,mthidx] = np.mean(mod_learner.l_tr(w=mod_chainer.l1.W.data.T, data=data))-np.mean(mod_learner.l_tr(w=w_star, data=data))\n", " riskvals[tri,idx,mthidx] = risk(w=mod_chainer.l1.W.data.T)-risk_star\n", " truedist[tri,idx,mthidx] = np.linalg.norm(w_star-mod_chainer.l1.W.data.T)-0\n", " idx += 1\n", "\n", "\n", "# Finally, take statistics of the performance metrics over all trials.\n", "ave_loss_tr = np.mean(loss_tr, axis=0)\n", "ave_riskvals = np.mean(riskvals, axis=0)\n", "ave_truedist = np.mean(truedist, axis=0)\n", "sd_loss_tr = np.std(loss_tr, axis=0)\n", "sd_riskvals = np.std(riskvals, axis=0)\n", "sd_truedist = np.std(truedist, axis=0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Exercises:__\n", "\n", "0. What is the role of mod_snap versus mod_chainer?\n", "\n", "0. What is going on in the iteration over zipped?\n", "\n", "0. Do you expect the performance of Chainer-based ERM-SVRG to be identical to the hand-made ERM-SVRG? Why or why not?" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "