From b0649a5e444bc82a944aef117c32aff21045a718 Mon Sep 17 00:00:00 2001 From: "Steven G. Johnson" Date: Sat, 8 Apr 2023 18:11:45 -0400 Subject: [PATCH] pset 4 solutions --- README.md | 2 +- psets/pset4sol.ipynb | 709 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 710 insertions(+), 1 deletion(-) create mode 100644 psets/pset4sol.ipynb diff --git a/README.md b/README.md index a369bd5..5b8e860 100644 --- a/README.md +++ b/README.md @@ -290,7 +290,7 @@ Described the KKT conditions for a (local) optimum/extremum (Boyd, section 5.5.3 * Quick review of augmented Lagrangians and ADMM from last lecture. Indicator function example from section III.4. * CCSA interior-point algorithm -* pset 4 solutions: coming soon +* [pset 4 solutions](psets/pset4sol.ipynb) * pset 5: coming soon, due 4/21 Went over very different example of a nonlinear optimization scheme, solving a fairly general inequality-constrained nonlinear-programming problem: the CCSA algorithm(s), as described by Svanberg (2002). This is a surprisingly simple algorithm (the [NLopt](http://ab-initio.mit.edu/nlopt) implementation is only 300 lines of C code), but is robust and provably convergent, and illustrates a number of important ideas in optimization: optimizing an approximation to update the parameters **x**, guarding the approximation with trust regions and penalty terms, and optimizing via the dual function (Lagrange multipliers). Like many optimization algorithms, the general ideas are very straightforward, but getting the details right can be delicate! diff --git a/psets/pset4sol.ipynb b/psets/pset4sol.ipynb new file mode 100644 index 0000000..67383da --- /dev/null +++ b/psets/pset4sol.ipynb @@ -0,0 +1,709 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73fdabd6", + "metadata": {}, + "source": [ + "# 18.065 Problem Set 4 Solutions" + ] + }, + { + "cell_type": "markdown", + "id": "0fb69bf7", + "metadata": {}, + "source": [ + "## Problem 1 (5+5 points)\n", + "\n", + "A \"convex set\" $S$ is one such that for any two points $x,y$ in $S$, the straight line connecting them is also in $S$. That is, $\\alpha x + (1-\\alpha)y \\in S$ for all $\\alpha \\in [0,1]$.\n", + "\n", + "**(a)** If $f_i(x)$ is a [convex function](https://en.wikipedia.org/wiki/Convex_function) (as defined in e.g. lecture 16), explain why the constraint $f_i(x) \\le 0$ defines a convex set of feasible points.\n", + "\n", + "**(b)** Explain why the intersection of two convex sets is a convex set. (Hence, the feasible set for many convex constraints is a convex set.)" + ] + }, + { + "cell_type": "markdown", + "id": "c5d653a2", + "metadata": {}, + "source": [ + "### Solution:\n", + "\n", + "**(a)** Suppose $x$ and $y$ are feasible, i.e. $f_i(x) \\le 0$ and $f_i(y) \\le 0$. Then, by the definition from class of convex functions, we have:\n", + "$$\n", + "f_i(\\alpha x + (1-\\alpha) y) \\le \\alpha f_i(x) + (1-\\alpha) f_i(y) \\le 0\n", + "$$\n", + "for any $\\alpha \\in [0,1]$, which means that $\\alpha x + (1-\\alpha) y$ is feasible. So, the feasible set is convex.\n", + "\n", + "**(b)** If $S$ is convex and $T$ is convex, then consider their intersection $S \\cap T$. $x, y \\in S \\cap T$ means that $x, y \\in S$ and $x,y \\in T$, by the definition of intersection. But since $S,T$ are convex, this means that $\\alpha x + (1-\\alpha) y$ is $\\in S$ and $\\in T$, so it's also in $S \\cap T$. Hence $S \\cap T$ is convex." + ] + }, + { + "cell_type": "markdown", + "id": "188e8b83", + "metadata": {}, + "source": [ + "## Problem 2 (10 points)\n", + "\n", + "Suppose we are solving the $\\ell^1$-regularized least-square problem:\n", + "$$\n", + "\\min_{x\\in \\mathbb{R}^n} \\left( \\Vert b - Ax \\Vert_2^2 + \\lambda \\Vert x \\Vert_1 \\right)\n", + "$$\n", + "where $\\lambda > 0$ is some regularization parameter and $ \\Vert x \\Vert_1 = \\sum_i |x_i|$ is the $\\ell^1$ norm.\n", + "\n", + "Similar to the examples in 16, show that this can be converted into a an equivalent [quadratic programming (QP)](https://en.wikipedia.org/wiki/Quadratic_programming) problem — a convex quadratic objective with affine constraints — by introducing one or more dummy variables (an \"epigraph\" formulation). This replaces the non-differentiable $\\ell^1$ problem with an equivalent *differentiable* problem with *differentiable constraints*." + ] + }, + { + "cell_type": "markdown", + "id": "d0aa3f44", + "metadata": {}, + "source": [ + "### Solution:\n", + "\n", + "We just need to apply the epigraph trick to *every term*. That is, suppose we introduce $n$ dummy variables $t \\in \\mathbb{R}^n$, and solve:\n", + "$$\n", + "\\min_{x,t\\in \\mathbb{R}^n} \\left( \\Vert b - Ax \\Vert_2^2 + \\sum_{i=1}^n t_i \\right)\n", + "$$\n", + "subject to the $2n$ affine constraints:\n", + "$$\n", + "t_i \\ge \\lambda x_i \\, \\qquad t_i \\ge -\\lambda x_i\n", + "$$\n", + "which will force $t_i = \\lambda |x_i|$ at the minimum. This is a [QP: a convex quadratic objective function + affine constraints](https://en.wikipedia.org/wiki/Quadratic_programming)." + ] + }, + { + "cell_type": "markdown", + "id": "73427817", + "metadata": {}, + "source": [ + "## Problem 3 (5 + 5 points)\n", + "\n", + "Let\n", + "$$\n", + "A(p) = A_0 + \\underbrace{\\begin{pmatrix} p_1 & & & \\\\ & p_2 & & \\\\ & & \\ddots & \\\\ & & & p_m \\end{pmatrix}}_{\\text{diagm(p)}}\n", + "$$\n", + "where $A_0$ is some $m \\times m$ matrix and $p \\in \\mathbb{R}^m$ are $m$ parameters.\n", + "\n", + "Now, suppose we compute\n", + "$$\n", + "f(p) = g(\\underbrace{A(p)^{-1} b}_{x(p)})\n", + "$$\n", + "where $g(x) = x^T G x$, $b \\in \\mathbb{R}^m$ is some vector, and $G = G^T$ is some symmetric $m \\times m$ matrix.\n", + "\n", + "**(a)** What is $\\nabla f$? Explain how you can compute *all m* components of $\\nabla f$ by solving only *two* $m \\times m$ systems followed by $\\Theta(m)$ additional work in *total*. *Clarification*: What I really want is for you to show that, in addition to the cost of computing $f(p)$ (which involves solving one system $Ax=b$), the additional work to compute $\\nabla f$ only involves solving one more system plus $\\Theta(m)$ arithmetic.\n", + "\n", + "**(b)** Implement your solution from (a) by filling in the function `∇f(p)` below, and check that it correctly predicts $df = f(p + dp) - f(p)$ (*approximately*) for a random small $dp$.\n", + "\n", + "### Solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "d16dcac8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-8.034026689349616" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using LinearAlgebra\n", + "\n", + "# some A₀, b, G for m=5\n", + "m = 5\n", + "A₀ = randn(m,m)\n", + "b = randn(m)\n", + "G = randn(m,m); G = G' + G\n", + "\n", + "# our functions\n", + "g(x) = x' * G * x\n", + "f(p) = g((A₀ + Diagonal(p)) \\ b)\n", + "\n", + "p = randn(m) # some random parameters\n", + "f(p) # make sure it gives a number out" + ] + }, + { + "cell_type": "markdown", + "id": "6a093e50", + "metadata": {}, + "source": [ + "**(a)**\n", + "\n", + "As explained in class (lecture 18) for a very similar problem, by the chain rule and the formula $d(A^{-1}) = -A^{-1} dA \\, A^{-1}$, we have:\n", + "$$\n", + "df = \\nabla g^T dx = \\underbrace{-\\nabla g^T A^{-1}}_{v^T} dA \\, \\underbrace{A^{-1} b}_x\n", + "$$\n", + "and so\n", + "$$\n", + "\\frac{\\partial f}{\\partial p_i} = v^T \\frac{\\partial A}{\\partial p_i} x\n", + "$$\n", + "where $v$ solves $A^T v = -\\nabla g$ (the \"adjoint\" equation), and $\\frac{\\partial A}{\\partial p_i}$ is just the matrix of all 0's except for a single 1 in the $i,i$ diagonal entry.\n", + "\n", + "So, to compute $\\nabla f$, we just need to do:\n", + "\n", + "1. Compute $x$ by solving $Ax=b$ and $\\nabla g = 2Gx$. (We need both $x$ and $Gx$ to compute $f$ in the first place, so this is \"free\"). \n", + "2. Solve $A^T v = -\\nabla g = -2Gx$: this is *one* additional system of the same size.\n", + "3. Compute the dot products $v^T \\frac{\\partial A}{\\partial p_i} x = v_i x_i$ for $i = 1,\\ldots,m$. This is $\\Theta(m)$ work: in Julia notation, we are just computing the elementwise product $\\nabla f = v \\mbox{ .* } x$.\n", + "\n", + "**(b)** The above algorithm is implemented as follows.\n", + "\n", + "To check that our $\\nabla f$ is correct, we simply want to check that our finite-difference `df` (for a small random `dp`) is $\\approx \\nabla f^T dp$. (The match won't be exact because `dp` is not infinitesimal.)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "12609b9b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "df = 1.404071513277927e-6\n", + "(∇f(p))' * dp = 1.4040715903119016e-6\n" + ] + }, + { + "data": { + "text/plain": [ + "1.4040715903119016e-6" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your solution to (b):\n", + "\n", + "function ∇f(p)\n", + " # in a practical setting, we would re-use this\n", + " # from the f(p) computation:\n", + " A = A₀ + Diagonal(p)\n", + " x = A \\ b\n", + " ∇g½ = G*x\n", + " \n", + " # adjoint equation:\n", + " # (in practice you might re-use the LU factorization of A!)\n", + " v = A' \\ (-2∇g½)\n", + " \n", + " ∇f = v .* x # elementwise products, from vᵀ(∂A/∂pᵢ)x\n", + "end\n", + "\n", + "dp = randn(m) * 1e-8 # a random small dp\n", + "df = f(p + dp) - f(p)\n", + "\n", + "# check: ∇f approximately predicts df\n", + "@show df # finite-difference approximation\n", + "@show ∇f(p)'dp # gradient prediction" + ] + }, + { + "cell_type": "markdown", + "id": "43a63240", + "metadata": {}, + "source": [ + "Yup, they match to about 8 significant digits, which is about as much as we can hope for given a finite $dp \\sim 10^{-8}$." + ] + }, + { + "cell_type": "markdown", + "id": "84c4326e", + "metadata": {}, + "source": [ + "## Problem 4 (5+5+5 points)\n", + "\n", + "In class, we considered steepest descent for $f(x) = \\kappa x_1^2 + x_2^2$ in $\\mathbb{R}^2$, and argued that for an arbitrary $x = [x_1,x_2]$ starting point and $\\kappa \\gg 1$, the steepest-descent step $x \\leftarrow x - sz$ is *approximately* $sz \\approx [x_1, x_2/\\kappa]$.\n", + "\n", + "### Part (a):\n", + "\n", + "**(a)** If $sz = [x_1, x_2/\\kappa]$ exactly, then on the next step we would have the new $x \\leftarrow x - sz = [0, (1-\\frac{1}{\\kappa}) x_2)]$. However, explain why a more careful calculation shows that the new $x - sz \\approx [O(1/\\kappa^2), x_2-\\frac{1}{\\kappa} x_2 + O(1/\\kappa^3)]$, i.e. the first component is proportional to $1/\\kappa^2$ to leading order in $1/\\kappa$.\n", + "\n", + "### Solution:" + ] + }, + { + "cell_type": "markdown", + "id": "946cd3d5", + "metadata": {}, + "source": [ + "From class, each step is $x \\to x - sz$ where $z = Ax = [\\kappa x_1, x_2]$ and\n", + "$$\n", + "s = \\frac{z^T z}{z^T A z} = \\frac{\\kappa^2 x_1^2 + x_2^2}{\\kappa^3 x_1^2 + x_2^2} = \\kappa^{-1} \\frac{ 1 + (x_2/x_1)^2 \\kappa^{-2}}{1 + (x_2/x_1)^2 \\kappa^{-3}}\n", + "$$\n", + "Taylor expanding in $\\kappa^{-1}$, we obtain:\n", + "$$\n", + "s \\approx \\kappa^{-1} + (x_2/x_1)^2 \\kappa^{-3} + O(\\kappa^{-4})\n", + "$$\n", + "Hence\n", + "$$\n", + "x - sz \\approx \\begin{pmatrix} x_1 - (1 + (x_2/x_1)^2 \\kappa^{-2} + O(\\kappa^{-3}))x_1 \\\\ x_2 - \\kappa^{-1} x_2 + O(\\kappa^{-3}) \\end{pmatrix}\n", + "= \\begin{pmatrix} - (x_2^2/x_1) \\kappa^{-2} + O(\\kappa^{-3}) \\\\ (1 - \\kappa^{-1}) x_2 + O(\\kappa^{-3}) \\end{pmatrix}\n", + "$$\n", + "which is of the suggested form." + ] + }, + { + "cell_type": "markdown", + "id": "07b0921e", + "metadata": {}, + "source": [ + "### Part (b):\n", + "\n", + "**(b)** If you start with an $x = [\\#/\\kappa^2, x_2]$, i.e. where the first component is proportional to $1/\\kappa^2$ and $\\#$ is some number of the same order of magnitude as $x_2$, show that after one steepest-descent step (for $\\kappa \\gg 1$) the $x_1$ component is *still* roughly order $1/\\kappa^2$ but of the opposite sign, and $x_2$ again subtracts a term roughly proportional to $x_2/\\kappa$.\n", + "\n", + "### Solution:" + ] + }, + { + "cell_type": "markdown", + "id": "faf3c6e5", + "metadata": {}, + "source": [ + "Conversely, if $x_1 = \\# / \\kappa$, we have $x_2/x_1 = \\kappa (x_2 / \\#)$ and $s$ becomes:\n", + "$$\n", + "s = \\kappa^{-1} \\frac{ 1 + (x_2/x_1)^2 \\kappa^{-2}}{1 + (x_2/x_1)^2 \\kappa^{-3}} = \\kappa^{-1} \\frac{ 1 + (x_2 / \\#)^2}{1 + (x_2 / \\#)^2 \\kappa^{-1}} \\approx \\kappa^{-1} (1 + (x_2 / \\#)^2) + O(\\kappa^{-2})\n", + "$$\n", + "So our steepest-descent step becomes, to leading order in $1/\\kappa$:\n", + "$$\n", + "x - sz \\approx \\begin{pmatrix} -(x_2 / \\#)^2 \\kappa^{-1} \\\\ x_2 \\left[1 - \\kappa^{-1} (1 + (x_2 / \\#)^2)\\right] \\end{pmatrix}\n", + "$$\n", + "i.e. the first term is still of order $1/\\kappa$ but with the opposite sign, and the second term has shrunk by a term of $O(x_2 / \\kappa)$. \n", + "\n", + "It is **zig-zagging slowly towards the solution!**\n", + "\n", + "**Optional**:\n", + "\n", + "We can also analyze the case that we get after one step, in part (a):\n", + "\n", + "If $x_1 = \\# / \\kappa^2$, we have to re-do our calculation of $s$, since $x_2/x_1 = \\kappa^2 (x_2 / \\#)$:\n", + "$$\n", + "s = \\kappa^{-1} \\frac{ 1 + (x_2/x_1)^2 \\kappa^{-2}}{1 + (x_2/x_1)^2 \\kappa^{-3}} = \\kappa^{-1} \\frac{ 1 + (x_2 / \\#)^2 \\kappa^{2}}{1 + (x_2 / \\#)^2 \\kappa} \\approx 1 - (\\# / x_2)^2 \\kappa^{-1} + O(\\kappa^{-2})\n", + "$$\n", + "So our steepest-descent step becomes, to leading order in $1/\\kappa$:\n", + "$$\n", + "x - sz \\approx \\kappa^{-1} \\begin{pmatrix} -\\# \\\\ +x_2(\\# / x_2)^2 \\end{pmatrix}\n", + "$$\n", + "i.e. *both* terms are of order $\\kappa^{-1}$, with the first term having an opposite sign from what it started with.\n", + "\n", + "(So, if this is the second iteration, then we are roughly back where we started but we gained a factor of $\\kappa^{-1}$. That means, for this starting point it actually converges *much* faster, gaining about a factor of $\\kappa^{-1}$. every 2 iterations. Not every starting point zig-zags! But we are mainly interested in the *worst-case* convergence since we can't count on getting lucky with our initial guess.)" + ] + }, + { + "cell_type": "markdown", + "id": "770529a8", + "metadata": {}, + "source": [ + "### Part (c):\n", + "\n", + "**(c)** Implement this steepest-descent process numerically for $\\kappa = 100$ and a starting point $x_1 = 0.01234567$ and $x_2 = 0.8910$. Plot $100x_1$ and $x_2$ for 100 iterations of steepest descent. A more careful analysis would show a convergence proportional to $\\left( \\frac{\\kappa - 1}{\\kappa + 1} \\right)^k$, where $k$ is the iteration number, following equation (4) in the Strang book — include this function for comparison on your plot.\n", + "\n", + "### Solution:\n", + "\n", + "Since $x_1$ is of order $1/\\kappa$, we expect something similar to the second case in part (b): from one iteration to the next, it should stay of roughly the same order but flip sign, and both components should asymptotically shrink slowly following equation (4):" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "bef5c3ee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "PyObject " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = [0.01234567, 0.8910] # starting guess\n", + "κ = 100\n", + "A = [ κ 0\n", + " 0 1 ]\n", + "xvals = [ x ] # list of x values\n", + "for k = 2:100\n", + " z = A*x\n", + " s = z'z / (z'*A*z) # = (κ^2*x[1]^2 + x[2]^2) / (κ^3*x[1]^2 + x[2]^2)\n", + " x = x - s*z\n", + " push!(xvals, x)\n", + "end\n", + "\n", + "using PyPlot\n", + "plot(1:100, getindex.(xvals,1) * κ, \"ro-\")\n", + "plot(1:100, getindex.(xvals,2), \"b*-\")\n", + "plot(1:100, ((κ-1)/(κ+1)).^(1:100), \"k--\")\n", + "xlabel(\"iteration\")\n", + "title(\"problem 4c\")\n", + "legend([L\"x_1\", L\"x_2\", \"Strang eq. (4)\"])" + ] + }, + { + "cell_type": "markdown", + "id": "6e9798d4", + "metadata": {}, + "source": [ + "## Problem 5 (10 points)\n", + "\n", + "In the Adam algorithm for stochastic optimization, we keep a \"running average\" (\"1st moment\") $m^{(k)}$ of the estimated gradients. If $\\tilde{\\nabla}f^{(k)}$ is our estimated (mini-batch) gradient at $x^{(k)}$ (the k-th step, for $k=1,2,3,\\ldots$), then the running average is computed as:\n", + "$$\n", + "m^{(k)} = \\beta_1 m^{(k-1)} + (1-\\beta_1) \\tilde{\\nabla}f^{(k)} \\, ,\n", + "$$\n", + "where $0 \\le \\beta_1 < 1$ (typically $\\beta_1 = 0.9$) is a given weight, and we define $m^{(0)} = \\vec{0}$.\n", + "\n", + "However, before we use the gradient to take a step, we \"de-bias\" it to:\n", + "$$\n", + "\\hat{m}^{(k)} = \\frac{m^{(k)}}{1 - \\beta_1^k}\n", + "$$\n", + "**Explain** why $\\hat{m}^{(k)}$ is exactly a weighted average of the estimates $\\tilde{\\nabla}f^{(j)}$ for $j = 1,\\ldots,k$ — that is, explain why dividing by $1 - \\beta_1^k$ exactly corresponds to dividing by the sum of the weights of each $\\tilde{\\nabla}f^{(j)}$ term. (The formulas for the [sum of a geometric series](https://en.wikipedia.org/wiki/Geometric_series) will be helpful.)\n", + "\n", + "### Solution:\n", + "\n", + "Just expanding out the formula (with $m^{(0)} = 0$ — there is no momentum to start with), we get:\n", + "$$\n", + "m^{(k)} = \\beta_1 m^{(k-1)} + (1-\\beta_1) \\tilde{\\nabla}f^{(k)} \\\\\n", + "= \\beta_1^2 m^{(k-2)} + \\beta_1 (1-\\beta_1) \\tilde{\\nabla}f^{(k-1)} + (1-\\beta_1) \\tilde{\\nabla}f^{(k)} \\\\\n", + "= \\beta_1^3 m^{(k-3)} + \\beta_1^2 (1-\\beta_1) \\tilde{\\nabla}f^{(k-2)} + \\beta_1 (1-\\beta_1) \\tilde{\\nabla}f^{(k-1)} + (1-\\beta_1) \\tilde{\\nabla}f^{(k)}\n", + "= \\cdots \\\\\n", + "= (1-\\beta_1) \\sum_{i=0}^{k-1} \\beta_1^i \\tilde{\\nabla}f^{(k-i)} \\, .\n", + "$$\n", + "The sum of all the coefficients is, using the usual formula for a finite geometric series:\n", + "$$\n", + "(1-\\beta_1) \\sum_{i=0}^{k-1} \\beta_1^i = (1-\\beta_1) \\frac{1 - \\beta_1^k}{1-\\beta_1} = 1 - \\beta_1^k \\, .\n", + "$$\n", + "So, $1 - \\beta_1^k$ is *exactly* the what we would divide by to make $\\hat{m}^{(k)}$ correspond to simply a weighted average of all the $\\tilde{\\nabla}f^{(k-i)}$ values. " + ] + }, + { + "cell_type": "markdown", + "id": "c7f174a6", + "metadata": {}, + "source": [ + "## Problem 6 (10 points)" + ] + }, + { + "cell_type": "markdown", + "id": "a3e6a871", + "metadata": {}, + "source": [ + "The Julia notebook from class (lecture 21) implemented the Adam algorithm for stochastic optimization. This code is reproduced below.\n", + "\n", + "A more recent algorithm, that has better convergence guarantees than Adam, is called [YOGI (Zaheer et al., 2018)](https://papers.nips.cc/paper_files/paper/2018/hash/90365351ccc7437a1309dc64e4db32a3-Abstract.html). Make a copy of the code below and **modify it to implement the YOGI algorithm** as described in algorithm 2 of the linked paper. (This algorithm omits the \"de-biasing\" step of problem 5, but you should include that in your implementation; the de-biasing is identical to that of Adam.) **Plot the convergence** of YOGI for this problem, with the same hyper-parameters, along with the original Adam algorithms (using different colors superimposed on a single plot)." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "2181180f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "PyObject Text(0.5, 1.0, '|error| in x')" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using LinearAlgebra, PyPlot, Random\n", + "\n", + "# typical Adam hyper-parameters\n", + "ϵ = 1e-8\n", + "β₁ = 0.9\n", + "β₂ = 0.999\n", + "\n", + "# more parameters\n", + "log₁₀α = -1\n", + "α = exp10(log₁₀α) # approx. maximum stepsize |Δx|\n", + "M = 1 # mini-batch size\n", + "iterations = 300\n", + "\n", + "Random.seed!(314159)\n", + "\n", + "x̂₀ = [1,2] # ground-truth model\n", + "x = [0.0,0.0]\n", + "X = [x]\n", + "ΔX = [norm(x - x̂₀)]\n", + "m = zero(x) # initial 1st-moment (mean gradient)\n", + "v = zero(x) # initial 2nd-moment (mean gradient.^2)\n", + "for t = 1:iterations\n", + " # generate a mini-batch of size M:\n", + " ã = randn(M)\n", + " b̃ = @. 1 + 2ã + randn()\n", + " Ã = [one.(ã) ã]\n", + "\n", + " # approximate gradient from this mini-batch\n", + " ∇f̃ = (2/M)*(Ã'*(Ã*x - b̃))\n", + "\n", + " # Adam update\n", + " m = β₁*m + (1-β₁)*∇f̃\n", + " v = β₂*v + (1-β₂)*(∇f̃.^2)\n", + " m̂ = m / (1 - β₁^t) # de-bias: normalize by total weights\n", + " v̂ = v / (1 - β₂^t) # de-bias: normalize by total weights\n", + " x = @. x - α * m̂ / (√v̂ + ϵ)\n", + "\n", + " push!(X, x)\n", + " push!(ΔX, norm(x - x̂₀))\n", + "end\n", + "\n", + "# objective function for contour plot:\n", + "a = randn(1000)\n", + "b = @. 1 + 2a + randn()\n", + "A = [one.(a) a]\n", + "f(x) = norm(b-A*x)^2 / length(b)\n", + "f(x1,x2) = f([x1,x2])\n", + "x1 = range(-2,3, length=100)\n", + "x2 = range(0,4,length=100)\n", + "fvals = f.(x1',x2)\n", + "\n", + "# plot progress\n", + "\n", + "figure(figsize=(10,4))\n", + "\n", + "subplot(1,2,1)\n", + "plt.subplots_adjust(wspace=0.4)\n", + "contour(x1', x2, fvals)\n", + "plot(x̂₀[1], x̂₀[2], \"r*\")\n", + "plot(getindex.(X,1), getindex.(X,2), \"ko-\")\n", + "xlabel(L\"x_1\")\n", + "ylabel(L\"x_2\")\n", + "title(\"gradient-descent iterates x\")\n", + "\n", + "subplot(1,2,2)\n", + "semilogy(ΔX, \"ko-\")\n", + "ylim(1e-2, 2)\n", + "xlabel(\"iteration\")\n", + "ylabel(L\"\\Vert x - \\hat{x} \\Vert\")\n", + "title(\"|error| in x\")" + ] + }, + { + "cell_type": "markdown", + "id": "f238f2e7", + "metadata": {}, + "source": [ + "### Solution:\n", + "\n", + "The only difference from Adam is the update of the \"variance\" estimate,\n", + "which is now:\n", + "$$\n", + "v^{(k)} = \\beta_2 v^{(k-1)} - (1 - \\beta_2) \\underbrace{\\text{sign}.(v^{(k-1)} - g^{(k)}\\mbox{.^2})}_\\mbox{new} \\mbox{ .* }g^{(k)}\\mbox{.^2}\n", + "$$\n", + "where $g^{(k)} = \\tilde{\\nabla} f^{(k)}$ is the estimated (mini-batch) gradient, the [sign function](https://docs.julialang.org/en/v1/base/math/#Base.sign) is ±1 depending on the sign of each element, and all the multiplications are taken elementwise (denoted with a `.` in Julia notation). Note also the minus sign in front of the second term.\n", + "\n", + "(In Julia, we can simply make *everything* elementwise in a line of code by putting `@.` before the calculation.)\n", + "\n", + "This is implemented below. In order to compare it quantitatively to Adam, we want to do things:\n", + "\n", + "1. Plot the Adam and Yogi results on the same plot.\n", + "2. To make the comparison more exact, use the *same \"random\" numbers* for both (i.e. the same mini-batches). (Otherwise we will get iterations that are qualitatively similar but quantitatively quite different.)\n", + "\n", + "One way to do the latter is to merge the loops — perform both the Adam and Yogi updates in the same loop, and save the iterates in different variables. An even more slick way to do this is to use the [`Random.seed!`](https://docs.julialang.org/en/v1/stdlib/Random/#Random.seed!) function to set a deterministic [seed](https://en.wikipedia.org/wiki/Random_seed) for the random-number generator. This allows us to generate the same \"random\" numbers both times. We can pick any seed we want, but I used `Random.seed!(314159)`:" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "e024300e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "PyObject Text(0.5, 1.0, '|error| in x')" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Random.seed!(314159)\n", + "\n", + "x = [0.0,0.0]\n", + "X_yogi = [x]\n", + "ΔX_yogi = [norm(x - x̂₀)]\n", + "m = zero(x) # initial 1st-moment (mean gradient)\n", + "v = zero(x) # initial 2nd-moment (mean gradient.^2)\n", + "for t = 1:iterations\n", + " # generate a mini-batch of size M:\n", + " ã = randn(M)\n", + " b̃ = @. 1 + 2ã + randn()\n", + " Ã = [one.(ã) ã]\n", + "\n", + " # approximate gradient from this mini-batch\n", + " ∇f̃ = (2/M)*(Ã'*(Ã*x - b̃))\n", + "\n", + " # Adam update\n", + " m = β₁*m + (1-β₁)*∇f̃\n", + " v = @. β₂*v - (1-β₂) * sign(v - ∇f̃^2) * (∇f̃^2)\n", + " m̂ = m / (1 - β₁^t) # de-bias: normalize by total weights\n", + " v̂ = v / (1 - β₂^t) # de-bias: normalize by total weights\n", + " x = @. x - α * m̂ / (√v̂ + ϵ)\n", + "\n", + " push!(X_yogi, x)\n", + " push!(ΔX_yogi, norm(x - x̂₀))\n", + "end\n", + "\n", + "\n", + "# plot progress\n", + "\n", + "figure(figsize=(10,4))\n", + "plt.suptitle(\"Problem 6: Adam and Yogi iterations\")\n", + "\n", + "subplot(1,2,1)\n", + "plt.subplots_adjust(wspace=0.4)\n", + "contour(x1', x2, fvals)\n", + "plot(x̂₀[1], x̂₀[2], \"r*\")\n", + "plot(getindex.(X,1), getindex.(X,2), \"ko-\")\n", + "plot(getindex.(X_yogi,1), getindex.(X_yogi,2), \"b*-\")\n", + "legend([\"Adam\", \"Yogi\"])\n", + "xlabel(L\"x_1\")\n", + "ylabel(L\"x_2\")\n", + "title(\"gradient-descent iterates x\")\n", + "\n", + "subplot(1,2,2)\n", + "semilogy(ΔX, \"ko-\")\n", + "semilogy(ΔX_yogi, \"b*-\")\n", + "ylim(1e-2, 2)\n", + "legend([\"Adam\", \"Yogi\"])\n", + "xlabel(\"iteration\")\n", + "ylabel(L\"\\Vert x - \\hat{x} \\Vert\")\n", + "title(\"|error| in x\")" + ] + }, + { + "cell_type": "markdown", + "id": "ee14d9bc", + "metadata": {}, + "source": [ + "When we plot them like this, we can see that there is virtually no difference! That's **because this example problem is so well-conditioned** (the $f$ contours are nearly circles), so the momentum terms make almost no difference — momentum-based algorithms should be essentially equivalent to steepest descent for well-conditioned problems.\n", + "\n", + "**Optional**:\n", + "\n", + "To actually see any difference between the iterates, let's plot the difference $\\Vert x_\\text{Adam} - x_\\text{Yogi} \\Vert$:" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "54da14e6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "PyObject Text(0.5, 1.0, 'Problem 6 extra: difference between Adam and Yogi iterates')" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "semilogy(norm.(X .- X_yogi), \"ko-\")\n", + "xlabel(\"iteration\")\n", + "ylabel(L\"\\Vert x_\\mathrm{Adam} - x_\\mathrm{Yogi} \\Vert\")\n", + "title(\"Problem 6 extra: difference between Adam and Yogi iterates\")" + ] + }, + { + "cell_type": "markdown", + "id": "bea01a59", + "metadata": {}, + "source": [ + "The differences are bigger than roundoff errors, but they are still quite small!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dd42d55", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "kernelspec": { + "display_name": "Julia 1.8.3", + "language": "julia", + "name": "julia-1.8" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}