{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Auxiliar 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este auxiliar veremos como usar el minimizador de scipy en general.\n",
    "\n",
    "Para mayor información visitar: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html           https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize_scalar.html#scipy.optimize.minimize_scalar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los minimizadores de scipy son funciónes que minimizan una función escalar objetivo, esta puede tener 1 o más variables. Exitsen 2 minimizadores de interés para nostros, $scipy.optimize.minimize$ y $scipy.optimize.minimize$_$scalar$, los cuales minimzan una función escalar de varias variables o una sola respectivamente\n",
    "\n",
    "Empezamos viendo el minimizador $scipy.optimize.minimize$_$scalar$ para una variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f80107fbbb0>]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.optimize import minimize_scalar\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Definimos una funcion escalar que posee un mínimo\n",
    "def f(x):\n",
    "    return (1/2)*x**4 - x**3 - 3*x**2 + (9/2)*x - (1/2)\n",
    "\n",
    "# Creamos un arreglo x para visualizar\n",
    "X = np.arange(-3,3.8, 0.01)\n",
    "\n",
    "# Visualizamos\n",
    "plt.plot(X, f(X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora procedemos a utilizar $scipy.optimize.minimize$_$scalar$, esta función admite como argumentos una función $fun$ a minimizar. Además es posible elegir el algoritmo a usar para minimizar la función $fun$, el cual por default es $method = 'brent'$ siendo este el método de Brent visto en clases. En nuestro caso haremos uso del método de Brent. Además, para el método de Brent es necesario entregarle 3 puntos que encajonen (bracketing como fue visto en clases) el mínimo, para esto se usa la variable $bracket$ la cual por default es $bracket =$ $'None'$, este argumento admite una secuencia.\n",
    "\n",
    "Conociendo esto buscamos uno de los mínimos de la función $f$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -8.09375\n",
       "    nfev: 14\n",
       "     nit: 10\n",
       " success: True\n",
       "       x: -1.5000000067470254"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bracket_f = (-2.5, -1, 0.5) # Secuencia que describe el bracketing para encontrar el primer minimo, es importante\n",
    "                            # notar que esto es una secuencia, por lo tanto se escribe con paréntesis.\n",
    "\n",
    "# Aplicamos la minimización\n",
    "minimize_scalar(f, bracket = bracket_f, method = 'brent')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que nos entrega $minimize$_$scalar$?, nos entrega un objeto de la clase $OptimizeResult$, la cual tiene distintos atributos asociados a la minimización de una función. En el caso que presentamos tiene 5 atributos; $fun$, el cual representa el valor del mínimo de la función a minimizar encontrado, $nfev$, que es el número de veces que la función a minimizar fue evaluada, $nit$, que es el número de iteraciones del método de minimización, $success$, que es un $boolean$ que entrega $True$ si la minimización fue exitosa o $False$ si no lo fue y $x$ que es la posición del mínimo encontrado.\n",
    "\n",
    "Como el resultado de $minimize$_$scalar$ es un objeto es posible utilizarlo al gusto de uno y llamar a sus atributos cuando uno desee:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-8.09375\n",
      "-1.5000000067470254\n",
      "True\n",
      "10\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "minimizacion_f = minimize_scalar(f, bracket = bracket_f, method = 'brent')\n",
    "print(minimizacion_f.fun)\n",
    "print(minimizacion_f.x)\n",
    "print(minimizacion_f.success)\n",
    "print(minimizacion_f.nit)\n",
    "print(minimizacion_f.nfev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Buscamos el otro mínimo de f:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4.223076211353316\n",
      "2.366025390455889\n",
      "True\n",
      "10\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "bracket_f = (0.5, 2, 3.5) # Secuencia que describe el bracketing para encontrar el primer minimo, es importante\n",
    "                            # notar que esto es una secuencia, por lo tanto se escribe con paréntesis.\n",
    "\n",
    "# Aplicamos la minimización\n",
    "minimizacion_f = minimize_scalar(f, bracket = bracket_f, method = 'brent')\n",
    "print(minimizacion_f.fun)\n",
    "print(minimizacion_f.x)\n",
    "print(minimizacion_f.success)\n",
    "print(minimizacion_f.nit)\n",
    "print(minimizacion_f.nfev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El minimizador de scipy tiene mas intrincancias que esto, también es posible entregar una tolerancia $tol$, la cual es dependiente del método que uno escoja para minimizar, $bounds$ que describe los bordes de la minimización para el método $bounded$, $args$ que son argumentos extra a pasar a la función objetivo, $options$ que es un diccionario de las opciones del solver que tiene 2 entradas, $maxiter$ que dexcribe el ḿaximo de iteraciones a realizar y $disp$ que define se se printean o no los mensajes de convergencia del método."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la próxima clase auxiliar veremos el minimizador para funciones que ademiten 1 o mas variables, $scipy.optimize.minimize$ con los métodos por default y el método de $Newton-CG$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}