From 514644194fec8d19b6a0ad41738909906fe0cf0d Mon Sep 17 00:00:00 2001 From: "Steven G. Johnson" Date: Sun, 23 Apr 2023 14:12:05 -0400 Subject: [PATCH] pset 5 solutions --- README.md | 2 +- psets/pset5sol.ipynb | 782 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 783 insertions(+), 1 deletion(-) create mode 100644 psets/pset5sol.ipynb diff --git a/README.md b/README.md index 4d57c5a..12dc249 100644 --- a/README.md +++ b/README.md @@ -332,7 +332,7 @@ http://dx.doi.org/10.1137/S1052623499362822) — I used the "linear and separabl ## Lecture 29 (Apr 21) * [(Discrete) convolutions](https://en.wikipedia.org/wiki/Convolution#Discrete_convolution), translation-invariance, [circulant matrices](https://en.wikipedia.org/wiki/Circulant_matrix), and convolutional neural networks (CNNs) -* pset 5 solutions: +* [pset 5 solutions](psets/pset5sol.ipynb) * pset 6: coming soon, due Friday May 5. **Further reading:** Strang textbook sections IV.2 (circulant matrices) and VII.2 (CNNs), and [OCW lecture 32](https://ocw.mit.edu/courses/18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018/resources/lecture-32-imagenet-is-a-cnn-the-convolution-rule/). See also these [Stanford lecture slides](http://cs231n.stanford.edu/slides/2016/winter1516_lecture7.pdf) and [MIT lecture slides](https://mit6874.github.io/assets/sp2020/slides/L03_CNNs_MK2.pdf). diff --git a/psets/pset5sol.ipynb b/psets/pset5sol.ipynb new file mode 100644 index 0000000..e79d0f8 --- /dev/null +++ b/psets/pset5sol.ipynb @@ -0,0 +1,782 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "701e5077", + "metadata": {}, + "source": [ + "# 18.065 Problem Set 5 Solutions\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "74f502b8", + "metadata": {}, + "source": [ + "## Problem 1 (5+6 points)\n", + "\n", + "Consider the following optimization problem:\n", + "$$\n", + "\\min_{x \\in \\mathbb{R}^2} x_1 \\\\\n", + "\\mbox{ subject to } x_2 \\le x_1^3 \\mbox{ and } x_2 \\ge 0 \\, .\n", + "$$\n", + "\n", + "**(a)** Draw a sketch of the feasible set in the $x_1, x_2$ plane and indicate the optimum $x_*$.\n", + "\n", + "**(b)** Show that the optimum $x_*$ does *not* satisfy the KKT conditions, but explain why this is possible because the LICQ conditions are violated (see the last slide of lecture 22).\n", + "\n", + "(Most problems have local minima that satisfy KKT, but you can see from the picture in (a) that this is a weird case!)" + ] + }, + { + "cell_type": "markdown", + "id": "0075a58b", + "metadata": {}, + "source": [ + "### Solution:\n", + "\n", + "**(a)** We will use PyPlot to draw our feasible set as a light-blue shaded region, which lies below the cubic $x_2 = x_1^3$ and above the $x_2=0$ axis, and hence is a **cusp-like** region that **only includes** $x_1 \\ge 0$.\n", + "\n", + "We also the primal optimum $x_*$ as a red star, which lies at $\\boxed{x_1 = 0, x_2 = 0}$, since this is the smallest $x_1$ point in the feasible region." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f147b166", + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "UndefVarError: plot not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: plot not defined", + "", + "Stacktrace:", + " [1] top-level scope", + " @ In[1]:3" + ] + } + ], + "source": [ + "# plot constraints\n", + "x₁ = range(-2,2,length=200)\n", + "plot(x₁, x₁.^3, \"b-\", linewidth=3)\n", + "text(1, 1.5, \"x₂ ≤ x₁³\", color=\"b\", rotation=45)\n", + "plot(x₁, zero(x₁), \"c-\", linewidth=3)\n", + "text(1.5, 0.4, \"x₂ ≥ 0\", color=\"c\")\n", + "\n", + "# plot feasible set\n", + "x₁⁺ = range(0,2,length=100)\n", + "fill_between(x₁⁺, zero(x₁⁺), x₁⁺.^3, color=(0.8,0.8,1))\n", + "text(1.4, 1.8, \"feasible\")\n", + "\n", + "# plot optimum\n", + "plot([0],[0],\"r*\",markersize=15)\n", + "text(0.1,0.4,L\"x_*\",color=\"r\")\n", + "\n", + "title(\"problem 1(a): feasible set and primal optimum\")\n", + "\n", + "# center the axes:\n", + "ax = gca()\n", + "ax.spines[\"left\"].set_position(\"zero\")\n", + "ax.spines[\"right\"].set_color(\"none\")\n", + "ax.spines[\"bottom\"].set_position(\"zero\")\n", + "ax.spines[\"top\"].set_color(\"none\")" + ] + }, + { + "cell_type": "markdown", + "id": "71a039ef", + "metadata": {}, + "source": [ + "**(b)** Our objective is $f_0(x) = x_1$, and our two constraints $f_i(x) \\le 0$ are $f_1(x) = x_2 - x_1^3$ and $f_2(x) = -x_2$. Therefore, at the optimum $x_* = (0,0)$, their gradients are:\n", + "$$\n", + "\\left. \\nabla f_0 \\right|_{x_*} = (1,0), \\qquad\n", + "\\left. \\nabla f_1 \\right|_{x_*} = (0,1), \\qquad\n", + "\\left. \\nabla f_2 \\right|_{x_*} = (0,-1) \\, .\n", + "$$\n", + "These are depicted graphically on the diagram below.\n", + "\n", + "But these **cannot possibly** satisfy the KKT condition $\\boxed{\\nabla L = 0}$ (for the Lagrangian $L = f_0 + \\lamba_1 f_1 + \\lambda_2 f_2$), for **any** Lagrange multipliers $\\lambda_1, \\lambda_2$, because $\\nabla f_0$ is **linearly independent of** (*orthogonal* to!) $\\nabla f_1$ and $\\nabla f_2$!\n", + "\n", + "It is possible to violate the KKT conditions at $x_*$ in this problem because the optimum **violates LICQ**: the constraint gradients $\\nabla f_1$ and $\\nabla f_2$ are linearly dependent (anti-parallel!) at $x_*$.\n", + "\n", + "This happens because the feasible set **has a cusp** (where two constraints become parallel) right at the primal optimum. Obviously, this is an odd case that doesn't arise too often in practice — most optimization problems typically satisfy LICQ and KKT conditions at any local optimum." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "344ade48", + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "UndefVarError: plot not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: plot not defined", + "", + "Stacktrace:", + " [1] top-level scope", + " @ In[2]:3" + ] + } + ], + "source": [ + "# plot constraints\n", + "x₁ = range(-2,2,length=200)\n", + "plot(x₁, x₁.^3, \"b-\", linewidth=3)\n", + "text(1, 1.5, \"x₂ ≤ x₁³\", color=\"b\", rotation=45)\n", + "plot(x₁, zero(x₁), \"c-\", linewidth=3)\n", + "text(1.5, 0.4, \"x₂ ≥ 0\", color=\"c\")\n", + "\n", + "# plot feasible set\n", + "x₁⁺ = range(0,2,length=100)\n", + "fill_between(x₁⁺, zero(x₁⁺), x₁⁺.^3, color=(0.8,0.8,1))\n", + "text(1.4, 1.8, \"feasible\")\n", + "\n", + "# plot optimum\n", + "plot([0],[0],\"r*\",markersize=15)\n", + "text(0.1,0.4,L\"x_*\",color=\"r\")\n", + "\n", + "title(L\"problem 1(b): gradients $\\nabla f_0, \\nabla f_1, \\nabla f_2$ at $x_*$\")\n", + "\n", + "\n", + "# gradients\n", + "arrow(0,0,0,5,color=\"b\", width=0.04, head_width=0.2, head_length=0.8)\n", + "text(0.1, 5, L\"\\nabla f_1 = \\nabla (x_2 - x_1^3)\", color=\"b\", fontsize=14)\n", + "\n", + "arrow(0,0,0,-5,color=\"c\", width=0.04, head_width=0.2, head_length=0.8)\n", + "text(0.1, -5, L\"\\nabla f_2 = \\nabla (-x_2)\", color=\"c\", fontsize=14)\n", + "\n", + "arrow(0,0,1,0,color=\"r\", width=0.2, head_width=0.8, head_length=0.2, zorder=10)\n", + "text(1, -2, L\"\\nabla f_0 = \\nabla (x_1)\", color=\"r\", fontsize=14)\n", + "\n", + "# center the axes:\n", + "ax = gca()\n", + "ax.spines[\"left\"].set_position(\"zero\")\n", + "ax.spines[\"right\"].set_color(\"none\")\n", + "ax.spines[\"bottom\"].set_position(\"zero\")\n", + "ax.spines[\"top\"].set_color(\"none\")" + ] + }, + { + "cell_type": "markdown", + "id": "3a49c4b1", + "metadata": {}, + "source": [ + "## Problem 2 (6+6+6 points)\n", + "\n", + "Consider the convex problem:\n", + "$$\n", + "\\min_{x\\in \\mathbb{R}^n} \\Vert b - Ax \\Vert_2^2 \\\\\n", + "\\mbox{ subject to } \\Vert x \\Vert_2^2 \\le r^2\n", + "$$\n", + "for some $r > 0$, $m \\times n$ matrix $A$ (of rank $n$), and $b \\in \\mathbb{R}^m$ — that is, least-squares optimization with the solution constrained to lie inside a sphere of radius $r$.\n", + "\n", + "**(a)** What is the Lagrange dual function $g(\\lambda)$? (You can give a closed-form expression. Hint: review Tikhonov-regularized least-squares.) Define a corresponding Julia function `g(λ; r=1.0)` for the sample parameters given below (this syntax defines an optional keyword argument `r` that defaults to $r=1$). Make a plot of $g(\\lambda)$ for $r=1$ and $r=0.5$ for $\\lambda \\ge 0$ to verify that it looks concave with a single maximum.\n", + "\n", + "**(b)** If the unconstrained least-square solution $\\hat{x} = (A^T A)^{-1} A^T b$ satisfies $\\Vert \\hat{x} \\Vert_2 < r$, then what must be true of the derivative $g'(0)$? What if $\\Vert \\hat{x} \\Vert_2 > r$?\n", + "\n", + "Check in Julia that $g'(0)$ matches your expectations by computing the derivative using automatic differentiation:\n", + "```jl\n", + "using ForwardDiff\n", + "dgdλ(λ; r=1.0) = ForwardDiff.derivative(λ -> g(λ; r=r), λ)\n", + "```\n", + "and evaluating it at `dgdλ(0; r=???)` for two values of `r`: one $r > \\Vert \\hat{x} \\Vert_2$ (so that the constraint is inactive) and one $r < \\Vert \\hat{x} \\Vert_2$ (so that the constraint is active).\n", + "\n", + "(In principle, you could take this derivative by hand using matrix calculus, but it's pretty error-prone.)\n", + "\n", + "**(c)** You can take the *second* derivative of $g(\\lambda)$ via AD by:\n", + "```jl\n", + "d²gdλ²(λ; r=0.5) = ForwardDiff.derivative(λ -> dgdλ(λ; r=0.5), λ)\n", + "```\n", + "Use this to implement a Newton iteration to maximize $g(\\lambda)$ (for $\\lambda \\ge 0$) by finding a root of $g'(\\lambda)$, starting with an initial guess of $\\lambda=0$, for $r = 0.5$. (It should converge in only a few iterations. The solution should have $\\lambda > 0$ in this case because ...?) To at least 8 significant digits, give the resulting dual optimum $\\lambda_*$ and the primal optimum $x_*$ (strong duality holds in this convex problem!), and check that $x_*$ is feasible." + ] + }, + { + "cell_type": "markdown", + "id": "15c6ac1c", + "metadata": {}, + "source": [ + "### Solution:\n", + "\n", + "**(a)** The dual function $g(\\lambda)$ is the found by minimizing the Lagrangian over $x$, i.e.\n", + "$$\n", + "g(\\lambda) = \\min_x \\underbrace{\\left[ \\Vert b - Ax \\Vert_2^2 + \\lambda (\\Vert x \\Vert_2^2 - r^2) \\right]}_{L(x,\\lambda)}\n", + "$$\n", + "where $\\Vert x \\Vert_2^2 - r^2 \\le 0$ is our inequality constraint. But this is exactly in the form of Tikhonov-regularized least-squares (plus a constant $-\\lambda r^2$), so we know from class that the solution is\n", + "$$\n", + "\\hat{x}_\\lambda = (A^T A + \\lambda I)^{-1} (A^T b)\n", + "$$\n", + "and hence $g(\\lambda) = \\boxed{L(\\hat{x}_\\lambda, \\lambda)}$ in terms of the formulas above. We can implement this as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1a89466c", + "metadata": {}, + "outputs": [], + "source": [ + "using LinearAlgebra\n", + "\n", + "m = 5\n", + "n = 4\n", + "A = [ -9 2 -2 3\n", + " -5 -3 9 3\n", + " -1 -6 9 -2\n", + " -3 -4 5 4\n", + " -8 9 -6 4 ]\n", + "b = [1,2,3,4,5];" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e5a615e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "g (generic function with 1 method)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function g(λ; r=1)\n", + " x̂_λ = (A'A + λ*I) \\ (A'b)\n", + " return norm(b - A*x̂_λ)^2 + λ*(norm(x̂_λ)^2 - r^2)\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "4001e6f4", + "metadata": {}, + "source": [ + "Plotting it, we obtain:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "521ec11c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(-5.0, 20.0)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using PyPlot\n", + "λ = range(0,100, length=1000)\n", + "plot(λ, g.(λ, r=0.5), \"r-\")\n", + "plot(λ, g.(λ, r=1), \"b--\")\n", + "title(L\"Problem 2(a): $g(\\lambda)$\")\n", + "xlabel(L\"\\lambda\")\n", + "ylabel(L\"g(\\lambda)\")\n", + "legend([L\"r=0.5\", L\"r=1\"])\n", + "ylim(-5, 20)" + ] + }, + { + "cell_type": "markdown", + "id": "864bda6b", + "metadata": {}, + "source": [ + "**(b)** If the unconstrained least-square solution satisfies the constraint, then the constraint is **inactive** and we expect that the corresponding Lagrange multiplier λ should be **zero** (corresponding to the \"complementary slackness\" KKT condition). In the dual problem, this corresponds to $$g(\\lambda)$$ for $$\\lambda \\ge 0$$ having its maximum at $\\lambda = 0$, corresponding to $\\boxed{g'(0) < 0}$ for $\\Vert \\hat{x} \\Vert_2 < r$.\n", + "\n", + "Conversely, if $\\Vert \\hat{x} \\Vert_2 > r$, then the constraint is **active** and we expect a dual maximum for $\\lambda > 0$, which requires $\\boxed{g'(0) > 0}$ in that case.\n", + "\n", + "To get an example of this, let's check the norm of the unconstrained least-square solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b7facd32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6508599263498679" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(A \\ b)" + ] + }, + { + "cell_type": "markdown", + "id": "32751a1e", + "metadata": {}, + "source": [ + "i.e. $\\Vert \\hat{x} \\Vert_2 = \\Vert (A^T A)^{-1} A^T b \\Vert_2 \\approx 0.651$, so the constraint should be inactive for any radius larger than that.\n", + "\n", + "For example, the constraint should be *inactive* for $r=1$ and *active* for $r = 0.5$, and we can see by inspection of the plot from part (a) that $g'(0)$ is $< 0$ and $> 0$ in these two cases, respectively. Quantitatively, we can use AD to get the derivative as suggested:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e3a11067", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dgdλ(0; r = 1.0) = -0.5763813562718445\n", + "dgdλ(0; r = 0.5) = 0.17361864372815555\n" + ] + }, + { + "data": { + "text/plain": [ + "0.17361864372815555" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using ForwardDiff\n", + "dgdλ(λ; r=1.0) = ForwardDiff.derivative(λ -> g(λ; r=r), λ)\n", + "\n", + "@show dgdλ(0; r=1.0)\n", + "@show dgdλ(0; r=0.5)" + ] + }, + { + "cell_type": "markdown", + "id": "4bf7db46", + "metadata": {}, + "source": [ + "Hurray, the signs match our expectations!" + ] + }, + { + "cell_type": "markdown", + "id": "41241ac1", + "metadata": {}, + "source": [ + "**(c)** As suggested, we can get a second derivative by:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ca12a000", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "d²gdλ² (generic function with 1 method)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d²gdλ²(λ; r=0.5) = ForwardDiff.derivative(λ -> dgdλ(λ; r=0.5), λ)" + ] + }, + { + "cell_type": "markdown", + "id": "484a2d51", + "metadata": {}, + "source": [ + "We can use this to implement a Newton iteration for the dual optimum. A Newton iteration to find a maximum $g'(\\lambda) = 0$ is just\n", + "$$\n", + "\\lambda \\longleftarrow \\lambda - \\frac{g'(\\lambda)}{g''(\\lambda)}\n", + "$$\n", + "We can start at $\\lambda = 0$. Of course, we first check whether $g'(0) > 0$ to be sure the constraint is active; otherwise, the dual optimum is simply $\\lambda = 0$.\n", + "\n", + "Given the dual optimum $\\lambda_*$, by strong duality we then have the corresponding primal optimum $x_* = \\hat{x}_{\\lambda_*}$ from part (a)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0d7df6ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dualopt (generic function with 1 method)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# find the dual optimum (maximizing g(λ))\n", + "# and return the dual and primal optima λ,x\n", + "function dualopt(r; rtol=10*eps(Float64), maxiter=100)\n", + " λ = zero(rtol)\n", + " g′ = dgdλ(λ; r=r)\n", + " if g′ > 0 # active constraint\n", + " for iter=1:maxiter # Newton iterations\n", + " g″ = d²gdλ²(λ; r=r)\n", + " @show Δλ = g′ / g″\n", + " λ -= Δλ\n", + " abs(Δλ) ≤ rtol * abs(λ) && break # converged\n", + " g′ = dgdλ(λ; r=r)\n", + " end\n", + " end\n", + " x̂_λ = (A'A + λ*I) \\ (A'b) # primal optimum x\n", + " return λ, x̂_λ\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "fff24d2b", + "metadata": {}, + "source": [ + "For $r = 0.5$, this gives (to nearly machine precision in only 7 Newton steps!)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4c37fc10", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Δλ = g′ / g″ = -2.976939515696773\n", + "Δλ = g′ / g″ = -2.197446051423321\n", + "Δλ = g′ / g″ = -0.7226090155288597\n", + "Δλ = g′ / g″ = -0.053830681767815296\n", + "Δλ = g′ / g″ = -0.000263613901856008\n", + "Δλ = g′ / g″ = -6.262750976944395e-9\n", + "Δλ = g′ / g″ = -2.9522501729702895e-15\n", + "(λ_opt, x_opt) = dualopt(0.5) = (5.951088884581378, [-0.2084478531413324, 0.23289743085848733, 0.29901616790443714, 0.25079396035796236])\n" + ] + }, + { + "data": { + "text/plain": [ + "(5.951088884581378, [-0.2084478531413324, 0.23289743085848733, 0.29901616790443714, 0.25079396035796236])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@show λ_opt, x_opt = dualopt(0.5)" + ] + }, + { + "cell_type": "markdown", + "id": "2cd47afd", + "metadata": {}, + "source": [ + "i.e. $\\boxed{\\lambda_* \\approx 5.951088884581378}$ and\n", + "$\\boxed{x_* \\approx [-0.2084478531413324, 0.23289743085848733, 0.29901616790443714, 0.25079396035796236]}$." + ] + }, + { + "cell_type": "markdown", + "id": "b4f2f1ef", + "metadata": {}, + "source": [ + "We should also check that $x_*$ is feasible, and in fact that the constraint is active ($\\Vert x_* \\Vert_2 = r$) since $\\lambda_* > 0$:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2c3d0137", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.5000000000000001" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm(x_opt)" + ] + }, + { + "cell_type": "markdown", + "id": "530e3856", + "metadata": {}, + "source": [ + "Yes, it is feasible and the constraint is active (up to roundoff errors)." + ] + }, + { + "cell_type": "markdown", + "id": "7878762b", + "metadata": {}, + "source": [ + "## Problem 3 (5+5+6 points)\n", + "\n", + "In this problem, you will use ADMM to solve the (primal) optimization problem from problem 2 above, for the parameters from problem 2c, using the equivalent formulation:\n", + "$$\n", + "\\min_{x \\in \\mathbb{R}^n} \\left( \\Vert b - Ax \\Vert_2^2 + \\begin{cases} 0 & \\Vert x \\Vert_2 \\le r \\\\ \\infty & \\mbox{otherwise} \\end{cases} \\right)\n", + "$$\n", + "where the second term is the \"indicator\" function of the feasible set (the radius-$r$ ball) as in lecture 24 and section III.4 of the text.\n", + "\n", + "A basic iteration of ADMM consists of 3 steps, as described in class and in the textbook:\n", + "\n", + "1. $x^{(k+1)} = \\mbox{arg }\\min_x \\Vert b - Ax \\Vert_2^2 + \\frac{\\rho}{2} \\Vert x - z^{(k)} + s^{(k)} \\Vert_2^2$ (for some penalty parameter $\\rho > 0$)\n", + "2. $z^{(k+1)}$ is the projection of $x^{(k+1)} + s^{(k)}$ onto the *closest* point in the feasible set.\n", + "3. $s^{(k+1)} = s^{(k)} + x^{(k+1)} - z^{(k+1)}$\n", + "\n", + "**(a)** Give a closed-form solution for step 1. (Hint: a problem from pset 3 should be helpful.)\n", + "\n", + "**(b)** Give a closed-form solution for step 2.\n", + "\n", + "**(c)** Implement this iteration in Julia to solve this problem with the parameters from 2c above, starting from $x = z = s = \\vec{0}$. Make a (semi-log) plot of the error $\\Vert x^{(k)} - x_* \\Vert_2$ versus $k$, where $x_*$ is your solution from 2c, for $\\rho = 1$ and $\\rho = 10$. (The error should converge to zero!)" + ] + }, + { + "cell_type": "markdown", + "id": "ee954031", + "metadata": {}, + "source": [ + "### Solution:\n", + "\n", + "**(a)** This is essentiallly the same as problem 3 of pset 3, with the \"prior\" $x_p = z^{(k)} - s^{(k)}$ and a penalty strength $\\delta^2 = \\rho/2$. Quoting the solutions from pset 3, we then have:\n", + "$$\n", + "\\boxed{x^{(k+1)} = \\left(A^T A + \\frac{\\rho}{2} I\\right)^{-1} \\left[A^T b + \\frac{\\rho}{2} (z^{(k)} - s^{(k)}) \\right]}\n", + "$$\n", + "\n", + "**(b)** To find the closest point to a vector $v$ on a sphere of radius $r$, if $\\Vert v \\Vert_2 > r$ we simply shrink $v$ onto the sphere: $v \\to v r / \\Vert v \\Vert_2$. This gives:\n", + "\n", + "$$\n", + "\\boxed{z^{(k+1)} = \\underbrace{\\left( x^{(k+1)} + s^{(k)} \\right)}_{v^{(k)}} \\frac{\\min \\{r, \\Vert v^{(k)} \\Vert_2\\}}{\\Vert v^{(k)} \\Vert_2} }\n", + "$$\n", + "where the second term shrinks the length if it is $> r$. (You can write this in other ways, of course, e.g. as an \"if–then\" statement.)\n", + "\n", + "**(c)** We'll implement a function `x,z,s = ADMM(x,z,s)` to take an ADMM step using the formulas above, and then iterate it for 1000 iterations and plot the convergence towards the optimum `x_opt` from problem 2(c) above:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e0f4080f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ADMM (generic function with 1 method)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# perform 1 ADMM step, returning the new x,z,s vectors\n", + "function ADMM(x,z,s; r=0.5, ρ=1)\n", + " x = (A'A + (ρ/2)*I) \\ (A'b + (ρ/2)*(z - s))\n", + " v = x + s\n", + " vlen = norm(v)\n", + " z = vlen ≤ r ? v : v * r/vlen\n", + " s = s + x - z\n", + " return x,z,s\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "483e87b6", + "metadata": {}, + "outputs": [], + "source": [ + "x = z = s = zeros(n)\n", + "err1 = [norm(x - x_opt)]\n", + "for i = 2:1000\n", + " x,z,s = ADMM(x,z,s; ρ=1)\n", + " push!(err1, norm(x - x_opt))\n", + "end\n", + "\n", + "x = z = s = zeros(n)\n", + "err10 = [norm(x - x_opt)]\n", + "for i = 2:1000\n", + " x,z,s = ADMM(x,z,s; ρ=10)\n", + " push!(err10, norm(x - x_opt))\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f2ce39f1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "PyObject " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "semilogy(err1, \"b.-\")\n", + "semilogy(err10, \"r.-\")\n", + "xlabel(\"iteration\")\n", + "ylabel(L\"error $\\Vert x - x_*\\Vert_2$\")\n", + "title(\"Problem 3c: ADMM convergence\")\n", + "legend([L\"\\rho = 1\", L\"\\rho = 10\"])" + ] + }, + { + "cell_type": "markdown", + "id": "5132c6e8", + "metadata": {}, + "source": [ + "As desired, the error is clearly converging towards zero — ADMM is converging towards the same solution as 2(c) above.\n", + "\n", + "Of course, it's not converging nearly as fast as a Newton iteration on the dual problem. In this problem, $\\rho = 10$ is converging significantly faster than $\\rho = 1$. \n", + "\n", + "**Optional commentary:**\n", + "\n", + "However, it's not simply a case of \"bigger is better\". For any given problem, there is an optimum $\\rho$ for ADMM convergence. Here, if we increase to $\\rho = 100$ the convergence is better, but if we go to $\\rho = 1000$ it gets *worse*. (You were not required to investigate this, however.) This kind of hyper-parameter tuning is painful to do by hand; a more sophisticated approach might be to try to update $\\rho$ dynamically depending on the convergence of the objective function and the constraint." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "040588ae", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "PyObject " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = z = s = zeros(n)\n", + "err100 = [norm(x - x_opt)]\n", + "for i = 2:1000\n", + " x,z,s = ADMM(x,z,s; ρ=100)\n", + " push!(err100, norm(x - x_opt))\n", + "end\n", + "\n", + "x = z = s = zeros(n)\n", + "err1000 = [norm(x - x_opt)]\n", + "for i = 2:1000\n", + " x,z,s = ADMM(x,z,s; ρ=1000)\n", + " push!(err1000, norm(x - x_opt))\n", + "end\n", + "\n", + "semilogy(err10, \"r.-\")\n", + "semilogy(err100, \"k.-\")\n", + "semilogy(err1000, \"g.-\")\n", + "xlabel(\"iteration\")\n", + "ylabel(L\"error $\\Vert x - x_*\\Vert_2$\")\n", + "title(\"Optional Problem 3c: ADMM convergence for larger ρ\")\n", + "legend([L\"\\rho = 10\", L\"\\rho = 100\", L\"\\rho = 1000\"])" + ] + } + ], + "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 +}