From c9f4e9aaaf14d8652793418778e9b5f36ebc778a Mon Sep 17 00:00:00 2001 From: Alexandr Katrutsa Date: Sat, 30 Jun 2018 00:02:21 +0300 Subject: [PATCH] Add en version of seminar 12, #15 --- 12-NumMethods/Seminar12en.ipynb | 1077 +++++++++++++++++++++++++++++++ 1 file changed, 1077 insertions(+) create mode 100644 12-NumMethods/Seminar12en.ipynb diff --git a/12-NumMethods/Seminar12en.ipynb b/12-NumMethods/Seminar12en.ipynb new file mode 100644 index 0000000..057ae94 --- /dev/null +++ b/12-NumMethods/Seminar12en.ipynb @@ -0,0 +1,1077 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "nbpresent": { + "id": "196b8a50-3d29-45c3-82b9-f4a09b49491d" + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Seminar 12\n", + "\n", + "# Introduction to numerical optimization (Y. E. Nesterov Introduction to convex optimization, ch. 1 $\\S$ 1.1)\n", + "\n", + " 1. Review of the spring term topics\n", + " 2. Problem statement\n", + " 3. General scheme of any optimization method\n", + " 4. Comparison of optimization methods\n", + " 5. Methods to solve one-dimansional minimization problem" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbpresent": { + "id": "2a573842-172b-4931-b0dd-9c9d3c47a450" + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Syllabus of the spring term\n", + "\n", + "Also, see on the [GitHub course page](https://github.com/amkatrutsa/MIPT-Opt#spring-term).\n", + "\n", + "1. Methods to solve **unconstrained** optimization problem\n", + " - One-dimensional optimization problem (**already today!**)\n", + " - Gradient descent\n", + " - Newton method\n", + " - Quasi-Newton methods\n", + " - Conjugate gradient method \n", + " - Optional:\n", + " - Lerast squares problem\n", + " - Optimal methods and lower bounds\n", + "2. Methods to solve **constrained** optimization problem\n", + " - Linear programming\n", + " - Projected gradient method and conditional gradient method\n", + " - Barrier method\n", + " - Penalty function methods\n", + " - Augmented Lagrangian method" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Organizational\n", + "\n", + "1. One seminar and one lecture per week\n", + "2. Two problem sets\n", + "3. Midterm in the middle of the term\n", + "4. Final test at the end of the term\n", + "5. Oral exam at the end of the term (grading for a semester is similar to the fall term)\n", + "6. Minitests in the deginning of every class\n", + "7. Homework assignment almost every week: $\\TeX$ or Jupyter Notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Problem statement\n", + "\n", + "\\begin{equation}\n", + "\\begin{split}\n", + "& \\min_{x \\in S} \\; f_0(x)\\\\\n", + "\\text{s.t. } & f_j(x) = 0, \\; j = 1,\\ldots,m\\\\\n", + "& g_k(x) \\leq 0, \\; k = 1,\\ldots,p\n", + "\\end{split}\n", + "\\end{equation}\n", + "where $S \\subseteq \\mathbb{R}^n$, $f_j: S \\rightarrow \\mathbb{R}, \\; j = 0,\\ldots,m$, $g_k: S \\rightarrow \\mathbb{R}, \\; k=1,\\ldots,p$\n", + "\n", + "All functions are at least continuous. \n", + "\n", + "Important fact: **nonlinear** optimization problem in its general form is \n", + "\n", + "**numerically intractable**!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Analytical results\n", + "- First order necessary condition: \n", + "\n", + "if $x^*$ is a local minimum point of the differentiable function $f(x)$, then \n", + "$$\n", + "f'(x^*) = 0\n", + "$$\n", + "- Second order necessary condition: \n", + "\n", + "if $x^*$ is a local minimum point of the twice differentiable function $f(x)$, then \n", + "\n", + "$$\n", + "f'(x^*) = 0 \\quad \\text{и} \\quad f''(x^*) \\succeq 0\n", + "$$\n", + "- Sufficient condition:\n", + "\n", + "Assume $f(x)$ is twice differentiable function and $x^*$ satisfies the following condition\n", + "\n", + "$$\n", + "f'(x^*) = 0 \\quad f''(x^*) \\succ 0,\n", + "$$\n", + "then $x^*$ is a strict local minimum point of function $f(x)$.\n", + "\n", + "**Remark**: check that you can prove these claims!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Features of numerical solutions\n", + "\n", + "1. Exact solution of the given problem is impossible due to precision of machine arithmetic\n", + "2. It is necessary to define the way to check if current point is a solution or not\n", + "3. It is necessary to define what information about the problem is stored" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## General iterative scheme\n", + "\n", + "Given: initial guess $x$, required tolerance $\\varepsilon$.\n", + "\n", + "```python\n", + "def GeneralScheme(x, epsilon):\n", + " \n", + " while StopCriterion(x) > epsilon:\n", + " \n", + " OracleResponse = RequestOracle(x)\n", + " \n", + " UpdateInformation(I, x, OracleResponse)\n", + " \n", + " x = NextPoint(I, x)\n", + " \n", + " return x\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Questions\n", + "1. What are the possible stopping criteria?\n", + "2. What is an oracle and what is it for?\n", + "3. What is information model?\n", + "4. How to get next point?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "#### Stopping criteria\n", + "1. Convergence in $x$: \n", + "$$\n", + "\\| x_k - x^* \\|_2 < \\varepsilon\n", + "$$ \n", + "2. Convergence in $f$: \n", + "$$\n", + "\\| f_k - f^* \\|_2 < \\varepsilon\n", + "$$ \n", + "3. Necessary condition \n", + "$$\n", + "\\| f'(x_k) \\|_2 < \\varepsilon\n", + "$$\n", + "\n", + "But we don't know $x^*$!\n", + "\n", + "Then\n", + "$$\n", + "\\|x_{k+1} - x_k \\| = \\|x_{k+1} - x_k + x^* - x^* \\| \\leq \\|x_{k+1} - x^* \\| + \\| x_k - x^* \\| \\leq 2\\varepsilon\n", + "$$\n", + "\n", + "The same is true for the convergence in $f$, but sometimes $f^*$ can be estimated!\n", + "\n", + "**Remark**: better practise is to use relative difference in argument and functional, for example $\\dfrac{\\|x_{k+1} - x_k \\|_2}{\\| x_k \\|_2}$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "#### What is oracle?\n", + "**Definition**: oracle is some abstact machine that responses on the sequaential method requests\n", + "\n", + "OOP analogy: \n", + "\n", + "- oracle is a virtual method of the base class\n", + "- every problem is derived class\n", + "- oracle is defined for every particular problem according to the declaration in the base class\n", + "\n", + "**Black box concept**\n", + "1. Iterative method can use only oracle responses\n", + "2. Oracle responses are *local*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "#### Information about the problem\n", + "1. Every oracle response gives **local** information about function behaviour in the given point\n", + "2. After aggregation of the oracle responses, we update **global** information about objective function:\n", + " - curvature\n", + " - descent direction\n", + " - etc" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "#### Compute next point\n", + "\n", + "$$\n", + "x_{k+1} = x_{k} + \\alpha_k h_k\n", + "$$\n", + "\n", + "- **Line search**: fix direction $h_k$ and search for this direction the optimal value of $\\alpha_k$\n", + "- **Trust region method**: fix appropriate size of *region* in some norm $\\| \\cdot \\| \\leq \\alpha$ and *model* of the objective function, which is a good approximation in the considered region.\n", + " Next, we search direction $h_k$, that minimizes the chosen model of the objective function and does not lead to the point $x_k + h_k$ lying outside of the considered region\n", + "\n", + "Questions:\n", + "1. How to choose $\\alpha_k$?\n", + "2. How to choose $h_k$?\n", + "3. How to choose model?\n", + "4. How to choose region?\n", + "5. How to choose region size? \n", + "\n", + "\n", + " In this course we consider only line search methods! \n", + " \n", + "However someiemes the concept of trust region methods will be helpful." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## How to compare optimization methods?\n", + "For given class of problems one can compare the following quantities:\n", + "1. Complexity\n", + " - analytical: number of the oracle requests to solve the problem with accuracy $\\varepsilon$\n", + " - arithmetic: total number of computations to solve the problem with accuracy $\\varepsilon$\n", + "2. Convergence speed\n", + "3. Experiments" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Convergence speed\n", + "1. Sublinear\n", + "$$\n", + "\\| x_{k+1} - x^* \\|_2 \\leq C k^{\\alpha},\n", + "$$\n", + "where $\\alpha < 0$ и $ 0 < C < \\infty$\n", + "2. Linear (geometric progression)\n", + "$$\n", + "\\| x_{k+1} - x^* \\|_2 \\leq Cq^k, \n", + "$$\n", + "where $q \\in (0, 1)$ and $ 0 < C < \\infty$\n", + "\n", + "3. Superlinear \n", + "$$\n", + "\\| x_{k+1} - x^* \\|_2 \\leq Cq^{k^p}, \n", + "$$\n", + "where $q \\in (0, 1)$, $ 0 < C < \\infty$ and $p > 1$\n", + "4. Quadratic\n", + "$$\n", + "\\| x_{k+1} - x^* \\|_2 \\leq C\\| x_k - x^* \\|^2_2, \\qquad \\text{or} \\qquad \\| x_{k+1} - x^* \\|_2 \\leq C q^{2^k}\n", + "$$\n", + "where $q \\in (0, 1)$ and $ 0 < C < \\infty$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Optimal methods: can we do better?\n", + "- Authors prove lower bounds of the convergence speed for given set of problems and methods of given order\n", + "- Next, the methods, for which these lower bounds are tight, were proposed $\\Rightarrow$ optimality is proved\n", + "- Later more about convergence theorem" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.rc(\"text\", usetex=True)\n", + "import numpy as np\n", + "C = 10\n", + "alpha = -0.5\n", + "q = 0.9\n", + "num_iter = 7\n", + "sublinear = np.array([C * k**alpha for k in range(1, num_iter + 1)])\n", + "linear = np.array([C * q**k for k in range(1, num_iter + 1)])\n", + "superlinear = np.array([C * q**(k**2) for k in range(1, num_iter + 1)])\n", + "quadratic = np.array([C * q**(2**k) for k in range(1, num_iter + 1)])\n", + "plt.figure(figsize=(12,8))\n", + "plt.semilogy(np.arange(1, num_iter+1), sublinear, \n", + " label=r\"Sublinear, $\\alpha = -0.5$\")\n", + "plt.semilogy(np.arange(1, num_iter+1), superlinear, \n", + " label=r\"Superlinear, $q = 0.5, p=2$\")\n", + "plt.semilogy(np.arange(1, num_iter+1), linear, \n", + " label=r\"Linear, $q = 0.5$\")\n", + "plt.semilogy(np.arange(1, num_iter+1), quadratic, \n", + " label=r\"Quadratic, $q = 0.5$\")\n", + "plt.xlabel(\"Number of iteration, $k$\", fontsize=24)\n", + "plt.ylabel(\"Error rate upper bound\", fontsize=24)\n", + "plt.legend(loc=\"best\", fontsize=28)\n", + "plt.xticks(fontsize = 28)\n", + "_ = plt.yticks(fontsize = 28)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Значение теорем сходимости (Б.Т. Поляк Введение в оптимизацию, гл. 1, $\\S$ 6)\n", + "1. Что дают теоремы сходимости\n", + " - класс задач, для которых можно рассчитывать на применимость метода (важно не завышать условия!)\n", + " - выпуклость\n", + " - гладкость\n", + " - качественное поведение метода\n", + " - существенно ли начальное приближение\n", + " - по какому функционалу есть сходимость\n", + " - оценку скорости сходимости\n", + " - теоретическая оценка поведения метода без проведения экспериментов\n", + " - определение факторов, которые влияют на сходимость (обусловленность, размерность, etc)\n", + " - иногда заранее можно выбрать число итераций для достижения заданной точности \n", + "\n", + "2. Что **НЕ** дают теоремы сходимости\n", + " - сходимость метода **ничего не говорит** о целесообразности его применения\n", + " - оценки сходимости зависят от неизвестных констант - неконструктивный характер\n", + " - учёт ошибок округления и точности решения вспомогательных задач\n", + " \n", + "**Мораль**: нужно проявлять разумную осторожность \n", + "\n", + "и здравый смысл!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Classes of problems\n", + "1. Uncontrained optimization\n", + " - Lipschitz objective function \n", + " - Lipschitz gradient of the objective function\n", + "2. Contrained optimization\n", + " - polytope\n", + " - sets with simple structure\n", + " - general form" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Classes of methods\n", + "1. Zero order method: oracle returns only objective function $f(x)$\n", + "\n", + "2. Fist order method : oracle returns objective function $f(x)$ and its gradient $f'(x)$\n", + "\n", + "3. Second order method: oracle returns objective function $f(x)$, its gradient $f'(x)$ and its hessian $f''(x)$.\n", + "\n", + "**Q**: do methods of higher order exist?\n", + "\n", + "1. One-step methods \n", + "$$\n", + "x_{k+1} = \\Phi(x_k)\n", + "$$\n", + "2. Multi-step methods\n", + "$$\n", + "x_{k+1} = \\Phi(x_k, x_{k-1}, ...)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## One-dimensional optimization\n", + "**Definition**. Funtion $f(x)$ is unimodal in interval $[a, b]$, if there exists such point $x^* \\in [a, b]$, that \n", + "- $f(x_1) > f(x_2)$ for any $a \\leq x_1 < x_2 < x^*$, \n", + "\n", + "and\n", + "\n", + "- $f(x_1) < f(x_2)$ for any $x^* < x_1 < x_2 \\leq b$.\n", + "\n", + "**Q**: what geometry of unimodal function?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Bisection method\n", + "\n", + "Idea from the first term CS course: divide given interval $[a,b]$ on two equal parts till minimum of the unimodal function is not found\n", + "\n", + "Denite by $N$ the number of computations of function $f$, then one can perform $K = \\frac{N - 1}{2}$ iterations and the following estimate holds: \n", + "$$\n", + "|x_{K+1} - x^*| \\leq \\frac{b_{K+1} - a_{K+1}}{2} = \\left( \\frac{1}{2} \\right)^{\\frac{N-1}{2}} (b - a) \\approx 0.5^{K} (b - a) \n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def binary_search(f, a, b, epsilon, callback=None):\n", + " c = (a + b) / 2.0\n", + " while abs(b - a) > epsilon:\n", + "# Check left subsegment\n", + " y = (a + c) / 2.0\n", + " if f(y) <= f(c):\n", + " b = c\n", + " c = y\n", + " else:\n", + "# Check right subsegment\n", + " z = (b + c) / 2.0\n", + " if f(c) <= f(z):\n", + " a = y\n", + " b = z\n", + " else:\n", + " a = c\n", + " c = z\n", + " if callback is not None:\n", + " callback(a, b)\n", + " return c" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def my_callback(a, b, left_bound, right_bound, approximation):\n", + " left_bound.append(a)\n", + " right_bound.append(b)\n", + " approximation.append((a + b) / 2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.313225746154785e-10\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %matplotlib inline\n", + "import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "left_boud_bs = []\n", + "right_bound_bs = []\n", + "approximation_bs = []\n", + "\n", + "callback_bs = lambda a, b: my_callback(a, b, \n", + " left_boud_bs, right_bound_bs, approximation_bs)\n", + "\n", + "# Target unimodal function on given segment\n", + "f = lambda x: (x - 2) * x * (x + 2)**2 # np.power(x+2, 2)\n", + "# f = lambda x: -np.sin(x)\n", + "x_true = -2\n", + "# x_true = np.pi / 2.0\n", + "a = -3\n", + "b = -1.5\n", + "epsilon = 1e-8\n", + "x_opt = binary_search(f, a, b, epsilon, callback_bs)\n", + "print(np.abs(x_opt - x_true))\n", + "plt.figure(figsize=(10,6))\n", + "plt.plot(np.linspace(a,b), f(np.linspace(a,b)))\n", + "plt.title(\"Objective function\", fontsize=20)\n", + "plt.xticks(fontsize=20)\n", + "_ = plt.yticks(fontsize=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Golden search method\n", + "Idea: divide interval $[a,b]$ not on two eqwual parts, but in the golden ratio.\n", + "\n", + "Estimate convergence speed like in bisection method:\n", + "$$\n", + "|x_{K+1} - x^*| \\leq b_{K+1} - a_{K+1} = \\left( \\frac{1}{\\tau} \\right)^{N-1} (b - a) \\approx 0.618^K(b-a),\n", + "$$\n", + "where $\\tau = \\frac{\\sqrt{5} + 1}{2}$.\n", + "\n", + "- Constant of linear convergence is **higher**, than corresponding constant in bisection method\n", + "- Number of function calls is **less** than for the bisection method " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def golden_search(f, a, b, tol=1e-5, callback=None):\n", + " tau = (np.sqrt(5) + 1) / 2.0\n", + " y = a + (b - a) / tau**2\n", + " z = a + (b - a) / tau\n", + " while b - a > tol:\n", + " if f(y) <= f(z):\n", + " b = z\n", + " z = y\n", + " y = a + (b - a) / tau**2\n", + " else:\n", + " a = y\n", + " y = z\n", + " z = a + (b - a) / tau\n", + " if callback is not None:\n", + " callback(a, b)\n", + " return (a + b) / 2.0" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.93889390875399e-18\n", + "9.549014390504221e-18\n", + "9.313225746154785e-10\n" + ] + } + ], + "source": [ + "left_boud_gs = []\n", + "right_bound_gs = []\n", + "approximation_gs = []\n", + "\n", + "cb_gs = lambda a, b: my_callback(a, b, left_boud_gs, right_bound_gs, approximation_gs)\n", + "x_gs = golden_search(f, a, b, epsilon, cb_gs)\n", + "\n", + "print(f(x_opt))\n", + "print(f(x_gs))\n", + "print(np.abs(x_opt - x_true))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Comparison of the methods for one-dimensional problem" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "plt.semilogy(np.arange(1, len(approximation_bs) + 1), np.abs(x_true - np.array(approximation_bs, dtype=np.float64)), label=\"Binary search\")\n", + "plt.semilogy(np.arange(1, len(approximation_gs) + 1), np.abs(x_true - np.array(approximation_gs, dtype=np.float64)), label=\"Golden search\")\n", + "plt.xlabel(r\"Number of iterations, $k$\", fontsize=24)\n", + "plt.ylabel(\"Error rate upper bound\", fontsize=24)\n", + "plt.legend(loc=\"best\", fontsize=24)\n", + "plt.xticks(fontsize = 24)\n", + "_ = plt.yticks(fontsize = 24)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21.1 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n", + "84.1 µs ± 345 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n" + ] + } + ], + "source": [ + "%timeit binary_search(f, a, b, epsilon)\n", + "%timeit golden_search(f, a, b, epsilon)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Example of other behaviour of the considered methods\n", + "\n", + "$$\n", + "f(x) = \\sin(\\sin(\\sin(\\sqrt{x}))), \\; x \\in [2, 60]\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5,1,'Objective function')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = lambda x: np.sin(np.sin(np.sin(np.sqrt(x))))\n", + "x_true = (3 * np.pi / 2)**2\n", + "a = 2\n", + "b = 60\n", + "epsilon = 1e-8\n", + "plt.plot(np.linspace(a,b), f(np.linspace(a,b)))\n", + "plt.xticks(fontsize = 24)\n", + "_ = plt.yticks(fontsize = 24)\n", + "plt.title(\"Objective function\", fontsize=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Comparison of convergence speed and execution time" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Bisection method" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1968899233115735e-07\n" + ] + } + ], + "source": [ + "left_boud_bs = []\n", + "right_bound_bs = []\n", + "approximation_bs = []\n", + "\n", + "callback_bs = lambda a, b: my_callback(a, b, \n", + " left_boud_bs, right_bound_bs, approximation_bs)\n", + "\n", + "x_opt = binary_search(f, a, b, epsilon, callback_bs)\n", + "print(np.abs(x_opt - x_true))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Golden section method" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1968899233115735e-07\n" + ] + } + ], + "source": [ + "left_boud_gs = []\n", + "right_bound_gs = []\n", + "approximation_gs = []\n", + "\n", + "cb_gs = lambda a, b: my_callback(a, b, left_boud_gs, right_bound_gs, approximation_gs)\n", + "x_gs = golden_search(f, a, b, epsilon, cb_gs)\n", + "\n", + "print(np.abs(x_opt - x_true))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Convergence" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'Error rate upper bound')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,6))\n", + "plt.semilogy(np.abs(x_true - np.array(approximation_bs, dtype=np.float64)), label=\"Binary\")\n", + "plt.semilogy(np.abs(x_true - np.array(approximation_gs, dtype=np.float64)), label=\"Golden\")\n", + "plt.legend(fontsize=24)\n", + "plt.xticks(fontsize=24)\n", + "_ = plt.yticks(fontsize=24)\n", + "plt.xlabel(r\"Number of iterations, $k$\", fontsize=24)\n", + "plt.ylabel(\"Error rate upper bound\", fontsize=24)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Execution time" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "461 µs ± 10.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n", + "436 µs ± 3.71 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" + ] + } + ], + "source": [ + "%timeit binary_search(f, a, b, epsilon)\n", + "%timeit golden_search(f, a, b, epsilon)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Recap\n", + "1. Introduction to numerical optimization\n", + "2. General scheme of any optimization method \n", + "3. How to compare optimization methods\n", + "4. Zoo of the optimization methods and problems\n", + "5. One-dimensional minimization" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3 (cvxpy)", + "language": "python", + "name": "cvxpy" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + }, + "nbpresent": { + "slides": { + "b738dfa0-30f4-4350-8338-c31d236608ec": { + "id": "b738dfa0-30f4-4350-8338-c31d236608ec", + "prev": null, + "regions": { + "96278b08-d857-478b-803c-5921bd08bbcd": { + "attrs": { + "height": 0.8, + "width": 0.8, + "x": 0.1, + "y": 0.1 + }, + "content": { + "cell": "196b8a50-3d29-45c3-82b9-f4a09b49491d", + "part": "whole" + }, + "id": "96278b08-d857-478b-803c-5921bd08bbcd" + }, + "9b98a7cc-d9d4-4a02-ac7e-30168dcde7af": { + "attrs": { + "height": 0.4, + "width": 0.8, + "x": 0.1, + "y": 0.5 + }, + "content": { + "cell": "2a573842-172b-4931-b0dd-9c9d3c47a450", + "part": "whole" + }, + "id": "9b98a7cc-d9d4-4a02-ac7e-30168dcde7af" + } + } + } + }, + "themes": {} + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}