chapter_optimization/convexity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convexity\n",
    ":label:`sec_convexity`\n",
    "\n",
    "Convexity plays a vital role in the design of optimization algorithms. This is largely due to the fact that it is much easier to analyze and test algorithms in this context. In other words, if the algorithm performs poorly even in the convex setting we should not hope to see great results otherwise. Furthermore, even though the optimization problems in deep learning are generally nonconvex, they often exhibit some properties of convex ones near local minima. This can lead to exciting new optimization variants such as :cite:`Izmailov.Podoprikhin.Garipov.ea.2018`. \n",
    "\n",
    "## Basics\n",
    "\n",
    "Let us begin with the basics.\n",
    "\n",
    "### Sets\n",
    "\n",
    "Sets are the basis of convexity. Simply put, a set $X$ in a vector space is convex if for any $a, b \\in X$ the line segment connecting $a$ and $b$ is also in $X$. In mathematical terms this means that for all $\\lambda \\in [0, 1]$ we have \n",
    "\n",
    "$$\\lambda \\cdot a + (1-\\lambda) \\cdot b \\in X \\text{ whenever } a, b \\in X.$$\n",
    "\n",
    "This sounds a bit abstract. Consider the picture :numref:`fig_pacman`. The first set is not convex since there are line segments that are not contained in it. The other two sets suffer no such problem. \n",
    "\n",
    "![Three shapes, the left one is nonconvex, the others are convex](https://raw.githubusercontent.com/d2l-ai/d2l-en/master/img/pacman.svg)\n",
    ":label:`fig_pacman`\n",
    "\n",
    "Definitions on their own are not particularly useful unless you can do something with them. In this case we can look at unions and intersections as shown in :numref:`fig_convex_intersect`. Assume that $X$ and $Y$ are convex sets. Then $X \\cap Y$ is also convex. To see this, consider any $a, b \\in X \\cap Y$. Since $X$ and $Y$ are convex, the line segments connecting $a$ and $b$ are contained in both $X$ and $Y$. Given that, they also need to be contained in $X \\cap Y$, thus proving our first theorem. \n",
    "\n",
    "![The intersection between two convex sets is convex](https://raw.githubusercontent.com/d2l-ai/d2l-en/master/img/convex-intersect.svg)\n",
    ":label:`fig_convex_intersect`\n",
    "\n",
    "We can strengthen this result with little effort: given convex sets $X_i$, their intersection $\\cap_{i} X_i$ is convex. \n",
    "To see that the converse is not true, consider two disjoint sets $X \\cap Y = \\emptyset$. Now pick $a \\in X$ and $b \\in Y$. The line segment in :numref:`fig_nonconvex` connecting $a$ and $b$ needs to contain some part that is neither in $X$ nor $Y$, since we assumed that $X \\cap Y = \\emptyset$. Hence the line segment is not in $X \\cup Y$ either, thus proving that in general unions of convex sets need not be convex. \n",
    "\n",
    "![The union of two convex sets need not be convex](https://raw.githubusercontent.com/d2l-ai/d2l-en/master/img/nonconvex.svg)\n",
    ":label:`fig_nonconvex`\n",
    "\n",
    "Typically the problems in deep learning are defined on convex domains. For instance $\\mathbb{R}^d$ is a convex set (after all, the line between any two points in $\\mathbb{R}^d$ remains in $\\mathbb{R}^d$). In some cases we work with variables of bounded length, such as balls of radius $r$ as defined by $\\{\\mathbf{x} | \\mathbf{x} \\in \\mathbb{R}^d \\text{ and } \\|\\mathbf{x}\\|_2 \\leq r\\}$. \n",
    "\n",
    "### Functions\n",
    "\n",
    "Now that we have convex sets we can introduce convex functions $f$. Given a convex set $X$ a function defined on it $f: X \\to \\mathbb{R}$ is convex if for all $x, x' \\in X$ and for all $\\lambda \\in [0, 1]$ we have \n",
    "\n",
    "$$\\lambda f(x) + (1-\\lambda) f(x') \\geq f(\\lambda x + (1-\\lambda) x').$$\n",
    "\n",
    "To illustrate this let us plot a few functions and check which ones satisfy the requirement. We need to import a few  libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [],
     "id": "",
     "n": "1"
    }
   },
   "outputs": [],
   "source": [
    "%mavenRepo snapshots https://oss.sonatype.org/content/repositories/snapshots/\n",
    "\n",
    "%maven ai.djl:api:0.7.0-SNAPSHOT\n",
    "%maven org.slf4j:slf4j-api:1.7.26\n",
    "%maven org.slf4j:slf4j-simple:1.7.26\n",
    "\n",
    "%maven ai.djl.mxnet:mxnet-engine:0.7.0-SNAPSHOT\n",
    "%maven ai.djl.mxnet:mxnet-native-auto:1.7.0-b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load ../utils/plot-utils\n",
    "%load ../utils/Functions.java"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ai.djl.ndarray.*;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us define a few functions, both convex and nonconvex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tech.tablesaw.plotly.traces.ScatterTrace;\n",
    "import tech.tablesaw.plotly.components.Axis.Spikes;\n",
    "\n",
    "// ScatterTrace.builder() does not support float[],\n",
    "// so we must convert to a double array first\n",
    "public double[] floatToDoubleArray(float[] x) {\n",
    "    double[] ret = new double[x.length];\n",
    "    for (int i = 0; i < x.length; i++) {\n",
    "        ret[i] = x[i];\n",
    "    }\n",
    "    return ret;\n",
    "}\n",
    "\n",
    "public Figure plotLineAndSegment(float[] x, float[] y, float[] segment, Function<Float, Float> func, \n",
    "                                 int width, int height) {\n",
    "    ScatterTrace trace = ScatterTrace.builder(floatToDoubleArray(x), floatToDoubleArray(y))\n",
    "        .mode(ScatterTrace.Mode.LINE)\n",
    "        .build();\n",
    "\n",
    "    ScatterTrace trace2 = ScatterTrace.builder(floatToDoubleArray(segment), \n",
    "                                               new double[]{func.apply(segment[0]), \n",
    "                                               func.apply(segment[1])})\n",
    "        .mode(ScatterTrace.Mode.LINE)\n",
    "        .build();\n",
    "\n",
    "    Layout layout = Layout.builder()\n",
    "        .height(height)\n",
    "        .width(width)\n",
    "        .showLegend(false)\n",
    "        .build();\n",
    "\n",
    "    return new Figure(layout, trace, trace2);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Function<Float, Float> f = x -> 0.5f * x * x; // Convex\n",
    "Function<Float, Float> g = x -> (float)Math.cos(Math.PI * x); // Nonconvex\n",
    "Function<Float, Float> h = x -> (float)Math.exp(0.5f * x); // Convex\n",
    "\n",
    "NDManager manager = NDManager.newBaseManager();\n",
    "\n",
    "NDArray X = manager.arange(-2f, 2f, 0.01f);\n",
    "float[] x = X.toFloatArray();\n",
    "float[] segment = new float[]{-1.5f, 1f};\n",
    "\n",
    "float[] fx = Functions.callFunc(x, f);\n",
    "float[] gx = Functions.callFunc(x, g);\n",
    "float[] hx = Functions.callFunc(x, h);\n",
    "\n",
    "display(plotLineAndSegment(x, fx, segment, f, 350, 300));\n",
    "display(plotLineAndSegment(x, gx, segment, g, 350, 300));\n",
    "display(plotLineAndSegment(x, hx, segment, h, 350, 300));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the cosine function is nonconvex, whereas the parabola and the exponential function are. Note that the requirement that $X$ is a convex set is necessary for the condition to make sense. Otherwise the outcome of $f(\\lambda x + (1-\\lambda) x')$ might not be well defined. Convex functions have a number of desirable properties.\n",
    "\n",
    "### Jensen's Inequality\n",
    "\n",
    "One of the most useful tools is Jensen's inequality. It amounts to a generalization of the definition of convexity:\n",
    "\n",
    "$$\\begin{aligned}\n",
    "    \\sum_i \\alpha_i f(x_i) & \\geq f\\left(\\sum_i \\alpha_i x_i\\right)\n",
    "    \\text{ and }\n",
    "    E_x[f(x)] & \\geq f\\left(E_x[x]\\right),\n",
    "\\end{aligned}$$\n",
    "\n",
    "where $\\alpha_i$ are nonnegative real numbers such that $\\sum_i \\alpha_i = 1$. In other words, the expectation of a convex function is larger than the convex function of an expectation. To prove the first inequality we repeatedly apply the definition of convexity to one term in the sum at a time. The expectation can be proven by taking the limit over finite segments.  \n",
    "\n",
    "One of the common applications of Jensen's inequality is with regard to the log-likelihood of partially observed random variables. That is, we use\n",
    "\n",
    "$$E_{y \\sim P(y)}[-\\log P(x \\mid y)] \\geq -\\log P(x).$$\n",
    "\n",
    "This follows since $\\int P(y) P(x \\mid y) dy = P(x)$. \n",
    "This is used in variational methods. Here $y$ is typically the unobserved random variable, $P(y)$ is the best guess of how it might be distributed and $P(x)$ is the distribution with $y$ integrated out. For instance, in clustering $y$ might be the cluster labels and $P(x \\mid y)$ is the generative model when applying cluster labels.\n",
    "\n",
    "\n",
    "## Properties\n",
    "\n",
    "Convex functions have a few useful properties. We describe them as follows.\n",
    "\n",
    "\n",
    "### No Local Minima\n",
    "\n",
    "In particular, convex functions do not have local minima. Let us assume the contrary and prove it wrong. If $x \\in X$ is a local minimum there exists some neighborhood of $x$ for which $f(x)$ is the smallest value. Since $x$ is only a local minimum there has to be another $x' \\in X$ for which $f(x') < f(x)$. However, by convexity the function values on the entire *line* $\\lambda x + (1-\\lambda) x'$ have to be less than $f(x')$ since for $\\lambda \\in [0, 1)$ \n",
    "\n",
    "$$f(x) > \\lambda f(x) + (1-\\lambda) f(x') \\geq f(\\lambda x + (1-\\lambda) x').$$\n",
    "\n",
    "This contradicts the assumption that $f(x)$ is a local minimum. For instance, the function $f(x) = (x+1) (x-1)^2$ has a local minimum for $x=1$. However, it is not a global minimum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Function<Float, Float> f = x -> (x - 1) * (x - 1) * (x + 1);\n",
    "\n",
    "float[] fx = Functions.callFunc(x, f);\n",
    "plotLineAndSegment(x, fx, segment, f, 400, 350);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fact that convex functions have no local minima is very convenient. It means that if we minimize functions we cannot \"get stuck\". Note, though, that this does not mean that there cannot be more than one global minimum or that there might even exist one. For instance, the function $f(x) = \\mathrm{max}(|x|-1, 0)$ attains its minimum value over the interval $[-1, 1]$. Conversely, the function $f(x) = \\exp(x)$ does not attain a minimum value on $\\mathbb{R}$. For $x \\to -\\infty$ it asymptotes to $0$, however there is no $x$ for which $f(x) = 0$.\n",
    "\n",
    "### Convex Functions and Sets\n",
    "\n",
    "Convex functions define convex sets as *below-sets*. They are defined as \n",
    "\n",
    "$$S_b := \\{x | x \\in X \\text{ and } f(x) \\leq b\\}.$$\n",
    "\n",
    "Such sets are convex. Let us prove this quickly. Remember that for any $x, x' \\in S_b$ we need to show that $\\lambda x + (1-\\lambda) x' \\in S_b$ as long as $\\lambda \\in [0, 1]$. But this follows directly from the definition of convexity since $f(\\lambda x + (1-\\lambda) x') \\leq \\lambda f(x) + (1-\\lambda) f(x') \\leq b$. \n",
    "\n",
    "Have a look at the function $f(x, y) = 0.5 x^2 + \\cos(2 \\pi y)$ below. It is clearly nonconvex. The level sets are correspondingly nonconvex. In fact, they are typically composed of disjoint sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TODO: Same issue as 11.1 tablesaw doesnt support mesh grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Nonconvex Function.](https://d2l-java-resources.s3.amazonaws.com/img/high_dim_nonconvex.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Derivatives and Convexity\n",
    "\n",
    "Whenever the second derivative of a function exists it is very easy to check for convexity. All we need to do is check whether $\\partial_x^2 f(x) \\succeq 0$, i.e., whether all of its eigenvalues are nonnegative. For instance, the function $f(\\mathbf{x}) = \\frac{1}{2} \\|\\mathbf{x}\\|^2_2$ is convex since $\\partial_{\\mathbf{x}}^2 f = \\mathbf{1}$, i.e., its derivative is the identity matrix. \n",
    "\n",
    "The first thing to realize is that we only need to prove this property for one-dimensional functions. After all, in general we can always define some function $g(z) = f(\\mathbf{x} + z \\cdot \\mathbf{v})$. This function has the first and second derivatives $g' = (\\partial_{\\mathbf{x}} f)^\\top \\mathbf{v}$ and $g'' = \\mathbf{v}^\\top (\\partial^2_{\\mathbf{x}} f) \\mathbf{v}$ respectively. In particular, $g'' \\geq 0$ for all $\\mathbf{v}$ whenever the Hessian of $f$ is positive semidefinite, i.e., whenever all of its eigenvalues are greater equal than zero. Hence back to the scalar case.\n",
    "\n",
    "To see that $f''(x) \\geq 0$ for convex functions we use the fact that \n",
    "\n",
    "$$\\frac{1}{2} f(x + \\epsilon) + \\frac{1}{2} f(x - \\epsilon) \\geq f\\left(\\frac{x + \\epsilon}{2} + \\frac{x - \\epsilon}{2}\\right) = f(x).$$\n",
    "\n",
    "Since the second derivative is given by the limit over finite differences it follows that \n",
    "\n",
    "$$f''(x) = \\lim_{\\epsilon \\to 0} \\frac{f(x+\\epsilon) + f(x - \\epsilon) - 2f(x)}{\\epsilon^2} \\geq 0.$$\n",
    "\n",
    "To see that the converse is true we use the fact that $f'' \\geq 0$ implies that $f'$ is a monotonically increasing function. Let $a < x < b$ be three points in $\\mathbb{R}$. We use the mean value theorem to express \n",
    "\n",
    "$$\\begin{aligned}\n",
    "f(x) - f(a) & = (x-a) f'(\\alpha) \\text{ for some } \\alpha \\in [a, x] \\text{ and } \\\\\n",
    "f(b) - f(x) & = (b-x) f'(\\beta) \\text{ for some } \\beta \\in [x, b].\n",
    "\\end{aligned}$$\n",
    "\n",
    "By monotonicity $f'(\\beta) \\geq f'(\\alpha)$, hence \n",
    "\n",
    "$$\\begin{aligned}\n",
    "    f(b) - f(a) & = f(b) - f(x) + f(x) - f(a) \\\\\n",
    "    & = (b-x) f'(\\beta) + (x-a) f'(\\alpha) \\\\\n",
    "    & \\geq (b-a) f'(\\alpha).\n",
    "\\end{aligned}$$\n",
    "\n",
    "By geometry it follows that $f(x)$ is below the line connecting $f(a)$ and $f(b)$, thus proving convexity. We omit a more formal derivation in favor of a graph below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Currently no good way of annotating in tablesaw.\n",
    "This graph however requires annotating to make sense."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Check Convexity.](https://d2l-java-resources.s3.amazonaws.com/img/convexity_check.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constraints\n",
    "\n",
    "One of the nice properties of convex optimization is that it allows us to handle constraints efficiently. That is, it allows us to solve problems of the form:\n",
    "\n",
    "$$\\begin{aligned} \\mathop{\\mathrm{minimize~}}_{\\mathbf{x}} & f(\\mathbf{x}) \\\\\n",
    "    \\text{ subject to } & c_i(\\mathbf{x}) \\leq 0 \\text{ for all } i \\in \\{1, \\ldots, N\\}.\n",
    "\\end{aligned}$$\n",
    "\n",
    "Here $f$ is the objective and the functions $c_i$ are constraint functions. To see what this does consider the case where $c_1(\\mathbf{x}) = \\|\\mathbf{x}\\|_2 - 1$. In this case the parameters $\\mathbf{x}$ are constrained to the unit ball. If a second constraint is $c_2(\\mathbf{x}) = \\mathbf{v}^\\top \\mathbf{x} + b$, then this corresponds to all $\\mathbf{x}$ lying on a halfspace. Satisfying both constraints simultaneously amounts to selecting a slice of a ball as the constraint set. \n",
    "\n",
    "### Lagrange Function\n",
    "\n",
    "In general, solving a constrained optimization problem is difficult. One way of addressing it stems from physics with a rather simple intuition. Imagine a ball inside a box. The ball will roll to the place that is lowest and the forces of gravity will be balanced out with the forces that the sides of the box can impose on the ball. In short, the gradient of the objective function (i.e., gravity) will be offset by the gradient of the constraint function (need to remain inside the box by virtue of the walls \"pushing back\"). Note that any constraint that is not active (i.e., the ball does not touch the wall) will not be able to exert any force on the ball. \n",
    "\n",
    "Skipping over the derivation of the Lagrange function $L$ (see e.g., the book by Boyd and Vandenberghe for details :cite:`Boyd.Vandenberghe.2004`) the above reasoning can be expressed via the following saddlepoint optimization problem:\n",
    "\n",
    "$$L(\\mathbf{x},\\alpha) = f(\\mathbf{x}) + \\sum_i \\alpha_i c_i(\\mathbf{x}) \\text{ where } \\alpha_i \\geq 0.$$ \n",
    "\n",
    "Here the variables $\\alpha_i$ are the so-called *Lagrange Multipliers* that ensure that a constraint is properly enforced. They are chosen just large enough to ensure that $c_i(\\mathbf{x}) \\leq 0$ for all $i$. For instance, for any $\\mathbf{x}$ for which $c_i(\\mathbf{x}) < 0$ naturally, we'd end up picking $\\alpha_i = 0$. Moreover, this is a *saddlepoint* optimization problem where one wants to *maximize* $L$ with respect to $\\alpha$ and simultaneously *minimize* it with respect to $\\mathbf{x}$. There is a rich body of literature explaining how to arrive at the function $L(\\mathbf{x}, \\alpha)$. For our purposes it is sufficient to know that the saddlepoint of $L$ is where the original constrained optimization problem is solved optimally.\n",
    "\n",
    "### Penalties\n",
    "\n",
    "One way of satisfying constrained optimization problems at least approximately is to adapt the Lagrange function $L$. Rather than satisfying $c_i(\\mathbf{x}) \\leq 0$ we simply add $\\alpha_i c_i(\\mathbf{x})$ to the objective function $f(x)$. This ensures that the constraints will not be violated too badly. \n",
    "\n",
    "In fact, we have been using this trick all along. Consider weight decay in :numref:`sec_weight_decay`. In it we add $\\frac{\\lambda}{2} \\|\\mathbf{w}\\|^2$ to the objective function to ensure that $\\mathbf{w}$ does not grow too large. Using the constrained optimization point of view we can see that this will ensure that $\\|\\mathbf{w}\\|^2 - r^2 \\leq 0$ for some radius $r$. Adjusting the value of $\\lambda$ allows us to vary the size of $\\mathbf{w}$.\n",
    "\n",
    "In general, adding penalties is a good way of ensuring approximate constraint satisfaction. In practice this turns out to be much more robust than exact satisfaction. Furthermore, for nonconvex problems many of the properties that make the exact approach so appealing in the convex case (e.g., optimality) no longer hold. \n",
    "\n",
    "### Projections\n",
    "\n",
    "An alternative strategy for satisfying constraints are projections. Again, we encountered them before, e.g., when dealing with gradient clipping in :numref:`sec_rnn_scratch`. There we ensured that a gradient has length bounded by $c$ via\n",
    "\n",
    "$$\\mathbf{g} \\leftarrow \\mathbf{g} \\cdot \\mathrm{min}(1, c/\\|\\mathbf{g}\\|).$$\n",
    "\n",
    "This turns out to be a *projection* of $g$ onto the ball of radius $c$. More generally, a projection on a (convex) set $X$ is defined as \n",
    "\n",
    "$$\\mathrm{Proj}_X(\\mathbf{x}) = \\mathop{\\mathrm{argmin}}_{\\mathbf{x}' \\in X} \\|\\mathbf{x} - \\mathbf{x}'\\|_2.$$\n",
    "\n",
    "It is thus the closest point in $X$ to $\\mathbf{x}$. This sounds a bit abstract. :numref:`fig_projections` explains it somewhat more clearly. In it we have two convex sets, a circle and a diamond. Points inside the set (yellow) remain unchanged. Points outside the set (black) are mapped to the closest point inside the set (red). While for $\\ell_2$ balls this leaves the direction unchanged, this need not be the case in general, as can be seen in the case of the diamond. \n",
    "\n",
    "![Convex Projections](https://raw.githubusercontent.com/d2l-ai/d2l-en/master/img/projections.svg)\n",
    ":label:`fig_projections`\n",
    "\n",
    "One of the uses for convex projections is to compute sparse weight vectors. In this case we project $\\mathbf{w}$ onto an $\\ell_1$ ball (the latter is a generalized version of the diamond in the picture above). \n",
    "\n",
    "## Summary\n",
    "\n",
    "In the context of deep learning the main purpose of convex functions is to motivate optimization algorithms and help us understand them in detail. In the following we will see how gradient descent and stochastic gradient descent can be derived accordingly. \n",
    "\n",
    "* Intersections of convex sets are convex. Unions are not.\n",
    "* The expectation of a convex function is larger than the convex function of an expectation (Jensen's inequality).\n",
    "* A twice-differentiable function is convex if and only if its second derivative has only nonnegative eigenvalues throughout. \n",
    "* Convex constraints can be added via the Lagrange function. In practice simply add them with a penalty to the objective function.\n",
    "* Projections map to points in the (convex) set closest to the original point. \n",
    "\n",
    "## Exercises\n",
    "\n",
    "1. Assume that we want to verify convexity of a set by drawing all lines between points within the set and checking whether the lines are contained. \n",
    "    * Prove that it is sufficient to check only the points on the boundary.\n",
    "    * Prove that it is sufficient to check only the vertices of the set.\n",
    "1. Denote by $B_p[r] := \\{\\mathbf{x} | \\mathbf{x} \\in \\mathbb{R}^d \\text{ and } \\|\\mathbf{x}\\|_p \\leq r\\}$ the ball of radius $r$ using the $p$-norm. Prove that $B_p[r]$ is convex for all $p \\geq 1$.\n",
    "1. Given convex functions $f$ and $g$ show that $\\mathrm{max}(f, g)$ is convex, too. Prove that $\\mathrm{min}(f, g)$ is not convex.\n",
    "1. Prove that the normalization of the softmax function is convex. More specifically prove the convexity of \n",
    "    $f(x) = \\log \\sum_i \\exp(x_i)$.\n",
    "1. Prove that linear subspaces are convex sets, i.e., $X = \\{\\mathbf{x} | \\mathbf{W} \\mathbf{x} = \\mathbf{b}\\}$. \n",
    "1. Prove that in the case of linear subspaces with $\\mathbf{b} = 0$ the projection $\\mathrm{Proj}_X$ can be written as $\\mathbf{M} \\mathbf{x}$ for some matrix $\\mathbf{M}$. \n",
    "1. Show that for convex twice differentiable functions $f$ we can write $f(x + \\epsilon) = f(x) + \\epsilon f'(x) + \\frac{1}{2} \\epsilon^2 f''(x + \\xi)$ for some $\\xi \\in [0, \\epsilon]$.\n",
    "1. Given a vector $\\mathbf{w} \\in \\mathbb{R}^d$ with $\\|\\mathbf{w}\\|_1 > 1$ compute the projection on the $\\ell_1$ unit ball. \n",
    "    * As intermediate step write out the penalized objective $\\|\\mathbf{w} - \\mathbf{w}'\\|_2^2 + \\lambda \\|\\mathbf{w}'\\|_1$ and compute the solution for a given $\\lambda > 0$. \n",
    "    * Can you find the 'right' value of $\\lambda$ without a lot of trial and error? \n",
    "1. Given a convex set $X$ and two vectors $\\mathbf{x}$ and $\\mathbf{y}$ prove that projections never increase distances, i.e., $\\|\\mathbf{x} - \\mathbf{y}\\| \\geq \\|\\mathrm{Proj}_X(\\mathbf{x}) - \\mathrm{Proj}_X(\\mathbf{y})\\|$."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "14.0.1+7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}