{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Lab #5. Semi-Stochastic Gradient Descent\n", "\n", "by Peter Richtarik\n", "\n", "The purpose of today's lab is to fool around with an efficient randomized algorithm for minimizing finite sums. We will work with Semi-stochastic Gradient Descent (S2GD) [3,4,5]. This algorithm has the same theoretical complexity as dfSDCA [1,2]. However, it operates very differently. Papers [3,4] describe the basic method - which works with one example (function) at a time, chosen uniformly at random. Generalization to a subset of examples (among other things) was done in [5]. The important distinction compared to dfSDCA is that S2GD does not need to keep many dual variables. Therefore, its memory footprint is much smaller. This is of extreme importance in training models such as Neural Networks. So, for this reason, S2GD is well suited for training NNs, but dfSDCA is not.\n", "\n", "## The problem\n", "\n", "We will be minimizing the average of $n$ smooth convex functions over a closed convex set $Q$: \n", "\n", "$$\\min_{x\\in Q \\subseteq \\mathbb{R}^d} \\left\\{ F(x) \\equiv \\frac{1}{n}\\sum_{i=1}^n f_i(x) \\right\\},$$\n", "\n", "using S2GD. We shall only experiment with the basic variant as described in [3].\n", "\n", "## Assumptions\n", "\n", "The analysis depends on the follwoing 3 assumptions.\n", "\n", "Assumption 1. The functions $f_i:\\mathbb{R}^d\\mapsto \\mathbb{R}$, $i=1,\\dots,n$, are $L$-smooth. That is, for all $x,y\\in \\mathbb{R}^d$ the following inequality holds:\n", "\n", "$$\\| \\nabla f_i(x) - \\nabla f_i(y) \\|_2 \\leq L\\|x-y\\|_2.$$\n", "\n", "This is equivalent to requiring that for all $x,h\\in \\mathbb{R}^d$ one has\n", "\n", "$$ f_i(x+h) \\leq f_i(x) + (\\nabla f_i(x))^\\top h + \\frac{L}{2}\\|h\\|_2^2.$$\n", "\n", "Assumption 2. The functions $f_i:\\mathbb{R}^d \\mapsto \\mathbb{R}$, $i=1,\\dots,n$, are convex. That is, for all $x,h\\in \\mathbb{R}^d$:\n", "\n", "$$f_i(x) + (\\nabla f_i(x))^\\top h \\leq f_i(x+h).$$\n", "\n", "Assumption 3. The function $F$ is $\\mu$-strongly convex for $\\mu>0$. That is, for all $x,h\\in \\mathbb{R}^d$:\n", "\n", "$$F(x) + (\\nabla F(x))^\\top h + \\frac{\\mu}{2}\\|h\\|_2^2 \\leq F(x+h).$$\n", "\n", "## S2GD algorithm\n", "\n", "1) Parameters: \n", "\n", "- stepsize $h>0$\n", "- number of outer iterations $T$\n", "- number of inner iteration $m$\n", "- starting point $x\\in \\mathbb{R}^d$\n", "\n", "2) For $t=0,1,\\dots,T$, repeat\n", "\n", "2.1) Compute $G = \\nabla F(x)$, set $x_{old} = x$\n", "\n", "2.2) For $k = 1, 2, \\dots, m$, repeat:\n", "- Draw $i\\in \\{1,2,\\dots,n\\}$, uniformly at random\n", "- Compute 2 stochastic gradients, one at the fresh point and at the old point: $\\nabla f_i(x)$ and $\\nabla f_i(x_{old})$\n", "- Apply update: $x\\leftarrow x - h (G + \\nabla f_i(x) - \\nabla f_i(x_{old}))$\n", "\n", "## Basic theory\n", "\n", " Theorem [3,4,5]. Under Assumptions 1, 2 and 3, after $k = O((n+\\kappa)\\log(1/\\epsilon))$ stochastic gradient evaluations, where $\\kappa = \\frac{L}{\\mu}$, S2GD outputs a solution for which \n", "\n", "$$\\mathbf{E}[F(x_k)-F(x_*)] \\leq \\epsilon (F(x_0)-F(x_*)).$$\n", "\n", "Since $n$ stochastic gradient evaluations is equivalent workload to 1 pass over data (and to 1 gradient step), S2GD only needs $O((1+\\kappa/n)\\log(1/\\epsilon))$ passes over data. In ML applications, usally $\\kappa\\approx n$. Hence $\\tilde{O}(1)$ passes over data will do! This rate is the same as that of dfSDCA and Quartz, when these are specialized to the serial uniform sampling ($\\hat{S}=\\{i\\}$ with probability $1/n$).\n", "\n", "In practice one can try to apply the method via various tricks, and with mixed success, to some functions which do not satisfy thee assumptions. Notably, strong convexity is not needed: the method can be shown to work also without it (but it is slower). Likewise, one can try to apply the method even if $f$ is not convex (such as in the case of NNs). Experiments show that one gets state-of-the-art or close performance this way.\n", " \n", "## References\n", "\n", "- [1] S. Shalev-Shwartz. SDCA without duality, ICML 2015 [arXiv:1502.06177]\n", "- [2] D. Csiba and P. Richtarik. Primal method for ERM with flexible mini-batching schemes and non-convex losses,\n", "arXiv:1506.02227, 2015\n", "- [3] J. Konecny and P. Richtarik. Semi-stochastic gradient descent. arXiv:1312.1666, 2013\n", "- [4] R. Johnson and R. Zhang. Accelerating stochastic gradient descent using predictive variance reduction. Neural Information Processing Systems, 2013\n", "- [5] J. Konecny, Jie Liu, Peter Richtarik and Martin Takac. Mini-batch semi-stochastic gradient descent in the proximal setting, IEEE Journal of Selected Topics in Signal Processing, 2015 [arXiv:1504.04407]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 1 - Ridge regression\n", "\n", "We will minimize the function:\n", "\n", "$$F(x) = \\frac{1}{2n}\\sum_{i=1}^n (X_i^T x - y_i)^2 + \\frac{\\mu}{2}\\|x\\|_2^2,$$\n", "\n", "where $X_1,\\dots,X_n \\in \\mathbb{R}^d$, $y_1,\\dots,y_n\\in \\mathbb{R}$ and $\\mu>0$. It is easy to see that $F(x)=\\frac{1}{n}\\sum_{i=1}^n f_i(x)$, where\n", "\n", "$$ f_i(x) = \\frac{1}{2} (X_i^T x - y_i)^2 + \\frac{\\mu}{2}\\|x\\|_2^2.$$\n", "\n", "Also notice that the gradient of $f_i$ is given by:\n", "\n", "$$\\nabla f_i(x) = (X_i^T x-y_i)X_i + \\mu x.$$\n", "\n", "We assume that $X_1,\\dots,X_n \\in \\mathbb{R}^d$ are stored as the columns of a $d\\times n$ matrix $X$ (technically, a \"sparse matrix\" in Julia). We also assume that the associated labels $y_1,\\dots,y_n\\in \\mathbb{R}$ are stored as entries of a vector $y\\in \\mathbb{R}^n$ (technically, an \"array\" in Julia).\n", "\n", "It can be verified that $f_i$ is $L_i$-smooth and convex, with \n", "\n", "$$L_i = \\|X_i\\|_2^2 + \\mu,$$ \n", "\n", "consequence of which is that all functions $f_i$ are $L$-smooth, where\n", "\n", "$$L = \\max_i L_i.$$\n", "\n", "We now define a function $\\verb\"Loss_quadratic\"$, whose output will be 3 functions and one scalar:\n", "- function $\\verb\"f(x,i)\"$ (=$f_i(x)$)\n", "- function $\\verb\"g(x,i)\"$ (=$\\nabla f_i(x)$)\n", "- function $\\verb\"F(x)\"$ (=$F(x)$)\n", "- scalar $\\verb\"L\"$ (=$L$) " ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Loss_quadratic (generic function with 1 method)" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function Loss_quadratic(X::SparseMatrixCSC, y::Array{Float64,1}, μ::Float64)\n", " \n", " n = size(X)[2]\n", " f(x, i) = (1/2)*((X[:,i]'*x)[1] - y[i])^2 + (μ/2)*(norm(x)^2) # function f_i\n", " g(x, i) = ((X[:,i]'*x)[1] - y[i]) * X[:,i] + μ*x # gradient of f_i\n", " F(x) = (1/n)*sum([f(x,i) for i=1:n]) # compute the function value\n", " L = maximum([norm(X[:,i])^2 + μ for i=1:n]) # compute maximum of the Lipschitz constants\n", " \n", " return (g, f, F, L)\n", " \n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 2 - The S2GD algorithm\n", "\n", "We now code up the algorithm itself..." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "S2GD (generic function with 1 method)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function S2GD(g::Function, F::Function, x0::Array{Float64,1}, n::Int64, T::Int64, m::Int64, h::Float64, track::Bool, progress::Bool) \n", " \n", " x = x0 # the starting point \n", " \n", " if track\n", " F_values = zeros(T+1) # prepares the array of Function Values\n", " F_values[1] = F(x)\n", " if progress \n", " println(\"#Starting function value: $(0), function value: $(F_values[1])\")\n", " end \n", " else\n", " if progress \n", " println(\"#Starting function value: $(F(x))\") \n", " end \n", " end\n", " \n", " for t=1:T\n", " \n", " G_old = (1/n)*sum([g(x,i) for i=1:n]) # compute gradient of F at x\n", " x_old = x # remember x for which gradient of F was computed\n", " \n", " # inner loop\n", " \n", " for k = 1:m\n", " i = rand(1:n) # sample index uniformly at random\n", " Δ = G_old + g(x,i) - g(x_old,i) # search direction = unbiased estimate of the gradient\n", " x = x - h*Δ # apply the update \n", " end\n", " \n", " if track\n", " F_values[t+1] = F(x)\n", " if progress\n", " println(\"#end of outer loop: $(t), function value: $(F_values[t+1])\")\n", " end\n", " else\n", " if progress \n", " println(\"#end of outer loop: $(t), function value: $(F(x))\") \n", " end \n", " end \n", " \n", " end\n", " \n", " if progress\n", " println(\"finished!\")\n", " end\n", " \n", " if track \n", " return F_values\n", " else\n", " return x\n", " end\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 3 - Plotting functions\n", "\n", "We now write 2 functions which will be used to visualize the results. We have used similar functions in a previous lab." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "S2GDCompare (generic function with 1 method)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using PyPlot\n", "\n", "function ShowConvergence(F_values, alg_list, F_star::Float64) \n", " ax = axes()\n", " for i=1:length(F_values)\n", " plt[:plot](0:(length(F_values[i])-1), abs(F_values[i]-F_star), \"-\", linewidth=3.0, label=alg_list[i])\n", " end\n", " legend(loc=\"upper right\")\n", " ylabel(L\"$F(x^{t}) - F(x^\\star)$\", fontsize=20)\n", " xlabel(\"Outer loops\")\n", " ax[:set_yscale](\"log\")\n", " plt[:show]()\n", "end\n", "\n", "function S2GDCompare(X::SparseMatrixCSC, g::Function, F::Function, x0::Array{Float64,1}, h_list, T::Int64, m::Int64, alg_list, progress::Bool)\n", " x_star = S2GD(g, F, x0, n, 100, n, h_list[1], false, false) \n", " F_star = F(x_star) \n", " \n", " if progress\n", " println(\"#End of deep phase. Best function value found: $(F_star)\")\n", " end\n", " \n", " F_values = [S2GD(g, F, x0, n, T, m, h_list[i], true, progress) for i = 1:length(h_list)]\n", "\n", " ShowConvergence(F_values, alg_list, F_star)\n", "end " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 4 - Generate synthetic data" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(g,f,F,2.3614476356438026)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = 100\n", "d = 10\n", "X = sprand(d, n, 0.1)\n", "y = rand(n) \n", "\n", "μ = 1/n # reglarization / strong convexity parameter\n", "g, f, F, L = Loss_quadratic(X,y,μ)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 5 - Run S2GD" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "#End of deep phase. Best function value found: 0.10757925816859462\n" ] }, { "data": { "image/png": "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", "text/plain": [ "Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "#Starting function value: 0, function value: 0.1685382470314124\n", "#end of outer loop: 1, function value: 0.12334451293267616\n", "#end of outer loop: 2, function value: 0.11843896556979104\n", "#end of outer loop: 3, function value: 0.10871993343978094\n", "#end of outer loop: 4, function value: 0.10780375722687582\n", "#end of outer loop: 5, function value: 0.1075953879154453\n", "#end of outer loop: 6, function value: 0.10758268501841226\n", "#end of outer loop: 7, function value: 0.10757969293813253\n", "#end of outer loop: 8, function value: 0.10757933132431881\n", "#end of outer loop: 9, function value: 0.10757926620425319\n", "#end of outer loop: 10, function value: 0.10757926016506966\n", "finished!\n", "#Starting function value: 0, function value: 0.1685382470314124\n", "#end of outer loop: 1, function value: 0.13193266541040718\n", "#end of outer loop: 2, function value: 0.11824417760558528\n", "#end of outer loop: 3, function value: 0.11224755550803485\n", "#end of outer loop: 4, function value: 0.1098493854306496\n", "#end of outer loop: 5, function value: 0.10878226488281724\n", "#end of outer loop: 6, function value: 0.10826447777302205\n", "#end of outer loop: 7, function value: 0.10800600440712874\n", "#end of outer loop: 8, function value: 0.10784969672845408\n", "#end of outer loop: 9, function value: 0.10776188327721777\n", "#end of outer loop: 10, function value: 0.10770661394274407\n", "finished!\n", "#Starting function value: 0, function value: 0.1685382470314124\n", "#end of outer loop: 1, function value: 0.1558942314910063\n", "#end of outer loop: 2, function value: 0.1460626089905729\n", "#end of outer loop: 3, function value: 0.1382024690495791\n", "#end of outer loop: 4, function value: 0.13206554945041676\n", "#end of outer loop: 5, function value: 0.1271042006380301\n", "#end of outer loop: 6, function value: 0.12323379230396914\n", "#end of outer loop: 7, function value: 0.12023219767248033\n", "#end of outer loop: 8, function value: 0.11780905619585091\n", "#end of outer loop: 9, function value: 0.11593188889162374\n", "#end of outer loop: 10, function value: 0.11438945696498025\n", "finished!\n" ] } ], "source": [ "alg_list = (\"A\", \"B\", \"C\")\n", "h_list = ( 1/(L), 1/(8*L), 1/(32*L) ) # stepsizes; do not change the first one\n", "x0 = zeros(d) # starting point\n", "T = 10 # number of outer iters \n", "m = n # number of inner iters\n", "\n", "S2GDCompare(X, g, F, x0, h_list, T, m, alg_list, true)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "## Problem A (Playing with parameters)\n", "\n", "Play with different settings for the parameters of the method: \n", "- stepsize $h$\n", "- number of outer iterations $T$\n", "- number of inner iterations $m$\n", "\n", "Some questions:\n", "- What happens if $T=1$ and $m$ is large?\n", "- What happens of $T$ is large and $m$ is small?\n", "- What happens if you use large stepsizes: $h = 10/L$ ?\n", "- What happens if you use small stepsizes: $h = 1/(100L) $\n", "- Start the method from a point close to the optimal point (which you can approximately compute by running S2GD). What happens? Will the method be driven awat from the optimum, as SGD (stochastic gradient descent) would?\n", "- Fix $T=10$. For the random dataset considered in this lab, what is the best value of $m$? And if $T=3$?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem B (Gradient Descent)\n", "\n", "Modify the input of the S2GD algorithm so that it becomes equivalent to gradient descent (GD) with fixed stepsize:\n", "\n", "$$x^{k+1} = x^k - \\frac{1}{L}\\nabla f(x^k).$$\n", "\n", "- Is this possible? That is, can we recover gradient descent as a special case of S2GD for a certain combination of parameters $h,T,m$?\n", "- How does GD compare with S2GD?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem C (Constrained S2GD)\n", "\n", "S2GD can also be applied to solving a constrained optimization problem of the form\n", "\n", "$$\\min_{x\\in Q} F(x),$$\n", "\n", "where $Q$ is a closed convex set. In particular, this is done by replacing the update step in the inner loop, which is of the form $x \\leftarrow x - h \\Delta$, by\n", "\n", "$$x \\leftarrow \\arg \\min_{z\\in Q} \\|z - (x - h \\Delta)\\|_2.$$ \n", "\n", "Write function $\\verb\"S2GDball\"$ which implements the above method for a ball constraint of radius $R$:\n", "\n", "$$Q = \\{x\\in \\mathbb{R}^d \\;:\\; \\|x\\|_2\\leq R\\}.$$\n", "\n", "For details about the theory behind a constrained version of S2GD, see [5].\n" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "## Problem D (Proximal S2GD)\n", "\n", "Sometimes one is interested in solving a composite problem of the form \n", "\n", "$$\\min_{x\\in \\mathbb{R}^d} F(x) + R(x),$$\n", "\n", "where $R:\\mathbb{R}^d \\to \\mathbb{R}\\cup \\{+\\infty\\}$ is a simple closed (i.e.,lower-semicontinuous) convex function. Examples:\n", "\n", "- No regularization: \n", "\n", "$$R(x) \\equiv 0$$\n", "\n", "- Constrained optimization: \n", "\n", "$$R(x) = \\begin{cases} 0, & \\text{if } x\\in Q,\\\\\n", "+\\infty, & \\text{otherwise.}\\end{cases}\n", "$$\n", "It can be shown that $R$ is closed and convex iff $Q$ is a closed convex set.\n", "\n", "- Sparse optimization: \n", "\n", "$$R(x) = \\lambda \\|x\\|_1, \\qquad \\text{where} \\qquad \\|x\\|_1 = \\sum_{i} |x_i| \\qquad \\text{and} \\qquad \\lambda>0$$ \n", "\n", "As $\\lambda$ increases, the solutions tend to become sparser, which often a desired feature in applications.\n", "\n", "S2GD can be modified to handle all of these cases; the complexity results hold without any changes. What changes is, as in the constrained S2GD described above, the update step. It becomes more involved:\n", "\n", "$$x \\leftarrow \\arg \\min_{z\\in Q} \\tfrac{1}{2}\\|z - (x - h \\Delta)\\|_2^2 + h R(z). \\tag{*}$$ \n", "\n", "- Verify that the above update reduces to standard S2GD when $R\\equiv 0$ and to constrained S2GD, when $R$ is given as above.\n", "- Code up S2GD with the L1 regularizer. In this case, one can solve the problem (*) in closed form. The operation is called soft thresholding. It is famous in optimization, signal processing and machine learning.\n", "\n", "For details and the underlying theory, see [5].\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem E (Mini-batch S2GD)\n", "\n", "It is possible to form the search direction by sampling more than a single function $i$. One can work with a subset instead (we have seen this in previous lectures for different algorithms). \n", "\n", "- Guess what would the update step look like if one was to sample a subset of $[n]=\\{1,2,\\dots,n\\}$ of size $\\tau$, uniformly at random\n", "- Code up the method and call it $\\verb\"mS2GD\"$. Run it for various values of $\\tau$ and interpret the results.\n", "\n", "For more details, see [5].\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem F (Efficient implementation for sparse data)\n", "\n", "When $d$ is also large, the computation of a stochastic gradiend, i.e., of $\\nabla f_i(x)$, can be large: $O(d)$. However, under certain conditions, it is possible to substantially accelerate even this step. The conditions are:\n", "- the data $X$ is sparse, \n", "- functions $f_i$ are of the form $f_i(x) = \\phi_i(X_i^T x)$ for some (smooth convex) functions $\\phi_i$,\n", "- the reglarizer $R$ is separable: $R(x) = \\sum_{i=1}^n R_i(x_i)$\n", "\n", "Come up with a way to accelerate the update step. Hint: The stochastic gradient for index $i$ will always be proportional to $X_i$ (and hence sparse). Think of a way to only update the cooridnates $j$ of $x$ for which the $j$th element of $X_{i}$ is nonzero. However, you need to make sure the algorithm does what it is supposed to do! It is just the implementation which needs to be changed, not the algorithm itself.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem G (Other loss functions)\n", "\n", "Replace the function $\\verb\"Loss_quadratic\"$ with $\\verb\"Loss_logistic\"$. Test the S2GD method on a real-life classification problem.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Julia 0.3.12", "language": "julia", "name": "julia-0.3" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "0.3.12" } }, "nbformat": 4, "nbformat_minor": 0 }