{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c77eabae",
   "metadata": {},
   "source": [
    "# Optimization and data loading\n",
    "\n",
    "We need to sort out two main task before starting with the assignments:\n",
    "* Loading data from time series and / or other kinds of files (**pandas**)\n",
    "* Running the nonlinear least squares optimization (**scipy.optimization**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c24e725d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c2a14fb",
   "metadata": {},
   "source": [
    "## Loading data with pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45269822",
   "metadata": {},
   "outputs": [],
   "source": [
    "korea_data = pd.read_csv(\"../notebooks/population-models/data/south_korea_covid_2020-03-15_2020-04-12.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a0e4bc06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>date</th>\n",
       "      <th>confirmed</th>\n",
       "      <th>recovered</th>\n",
       "      <th>deaths</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2020-03-15</td>\n",
       "      <td>8162</td>\n",
       "      <td>510</td>\n",
       "      <td>75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2020-03-16</td>\n",
       "      <td>8236</td>\n",
       "      <td>1137</td>\n",
       "      <td>75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2020-03-17</td>\n",
       "      <td>8320</td>\n",
       "      <td>1407</td>\n",
       "      <td>81</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2020-03-18</td>\n",
       "      <td>8413</td>\n",
       "      <td>1540</td>\n",
       "      <td>84</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2020-03-19</td>\n",
       "      <td>8565</td>\n",
       "      <td>1540</td>\n",
       "      <td>91</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         date  confirmed  recovered  deaths\n",
       "0  2020-03-15       8162        510      75\n",
       "1  2020-03-16       8236       1137      75\n",
       "2  2020-03-17       8320       1407      81\n",
       "3  2020-03-18       8413       1540      84\n",
       "4  2020-03-19       8565       1540      91"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "korea_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8d4adba3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    8162\n",
       "1    8236\n",
       "2    8320\n",
       "Name: confirmed, dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can access the data column by column, as numpy arrays\n",
    "confirmed = korea_data[\"confirmed\"]\n",
    "confirmed[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5cf84cc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>date</th>\n",
       "      <th>confirmed</th>\n",
       "      <th>recovered</th>\n",
       "      <th>deaths</th>\n",
       "      <th>R</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2020-03-15</td>\n",
       "      <td>8162</td>\n",
       "      <td>510</td>\n",
       "      <td>75</td>\n",
       "      <td>585</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2020-03-16</td>\n",
       "      <td>8236</td>\n",
       "      <td>1137</td>\n",
       "      <td>75</td>\n",
       "      <td>1212</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2020-03-17</td>\n",
       "      <td>8320</td>\n",
       "      <td>1407</td>\n",
       "      <td>81</td>\n",
       "      <td>1488</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2020-03-18</td>\n",
       "      <td>8413</td>\n",
       "      <td>1540</td>\n",
       "      <td>84</td>\n",
       "      <td>1624</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2020-03-19</td>\n",
       "      <td>8565</td>\n",
       "      <td>1540</td>\n",
       "      <td>91</td>\n",
       "      <td>1631</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         date  confirmed  recovered  deaths     R\n",
       "0  2020-03-15       8162        510      75   585\n",
       "1  2020-03-16       8236       1137      75  1212\n",
       "2  2020-03-17       8320       1407      81  1488\n",
       "3  2020-03-18       8413       1540      84  1624\n",
       "4  2020-03-19       8565       1540      91  1631"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also create new columns if needed\n",
    "korea_data[\"R\"] = korea_data[\"recovered\"] + korea_data[\"deaths\"]\n",
    "korea_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "713e61b4",
   "metadata": {},
   "source": [
    "## Running nonlinear least squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "17ff1583",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function least_squares in module scipy.optimize._lsq.least_squares:\n",
      "\n",
      "least_squares(\n",
      "    fun,\n",
      "    x0,\n",
      "    jac='2-point',\n",
      "    bounds=(-inf, inf),\n",
      "    method='trf',\n",
      "    ftol=1e-08,\n",
      "    xtol=1e-08,\n",
      "    gtol=1e-08,\n",
      "    x_scale=None,\n",
      "    loss='linear',\n",
      "    f_scale=1.0,\n",
      "    diff_step=None,\n",
      "    tr_solver=None,\n",
      "    tr_options=None,\n",
      "    jac_sparsity=None,\n",
      "    max_nfev=None,\n",
      "    verbose=0,\n",
      "    args=(),\n",
      "    kwargs=None,\n",
      "    callback=None,\n",
      "    workers=None\n",
      ")\n",
      "    Solve a nonlinear least-squares problem with bounds on the variables.\n",
      "\n",
      "    Given the residuals f(x) (an m-D real function of n real\n",
      "    variables) and the loss function rho(s) (a scalar function), `least_squares`\n",
      "    finds a local minimum of the cost function F(x)::\n",
      "\n",
      "        minimize F(x) = 0.5 * sum(rho(f_i(x)**2), i = 0, ..., m - 1)\n",
      "        subject to lb <= x <= ub\n",
      "\n",
      "    The purpose of the loss function rho(s) is to reduce the influence of\n",
      "    outliers on the solution.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    fun : callable\n",
      "        Function which computes the vector of residuals, with the signature\n",
      "        ``fun(x, *args, **kwargs)``, i.e., the minimization proceeds with\n",
      "        respect to its first argument. The argument ``x`` passed to this\n",
      "        function is an ndarray of shape (n,) (never a scalar, even for n=1).\n",
      "        It must allocate and return a 1-D array_like of shape (m,) or a scalar.\n",
      "        If the argument ``x`` is complex or the function ``fun`` returns\n",
      "        complex residuals, it must be wrapped in a real function of real\n",
      "        arguments, as shown at the end of the Examples section.\n",
      "    x0 : array_like with shape (n,) or float\n",
      "        Initial guess on independent variables. If float, it will be treated\n",
      "        as a 1-D array with one element. When `method` is 'trf', the initial\n",
      "        guess might be slightly adjusted to lie sufficiently within the given\n",
      "        `bounds`.\n",
      "    jac : {'2-point', '3-point', 'cs', callable}, optional\n",
      "        Method of computing the Jacobian matrix (an m-by-n matrix, where\n",
      "        element (i, j) is the partial derivative of f[i] with respect to\n",
      "        x[j]). The keywords select a finite difference scheme for numerical\n",
      "        estimation. The scheme '3-point' is more accurate, but requires\n",
      "        twice as many operations as '2-point' (default). The scheme 'cs'\n",
      "        uses complex steps, and while potentially the most accurate, it is\n",
      "        applicable only when `fun` correctly handles complex inputs and\n",
      "        can be analytically continued to the complex plane. If callable, it is used as\n",
      "        ``jac(x, *args, **kwargs)`` and should return a good approximation\n",
      "        (or the exact value) for the Jacobian as an array_like (np.atleast_2d\n",
      "        is applied), a sparse array (csr_array preferred for performance) or\n",
      "        a `scipy.sparse.linalg.LinearOperator`.\n",
      "\n",
      "        .. versionchanged:: 1.16.0\n",
      "            An ability to use the '3-point', 'cs' keywords with the 'lm' method.\n",
      "            Previously 'lm' was limited to '2-point' and callable.\n",
      "\n",
      "    bounds : 2-tuple of array_like or `Bounds`, optional\n",
      "        There are two ways to specify bounds:\n",
      "\n",
      "        1. Instance of `Bounds` class\n",
      "        2. Lower and upper bounds on independent variables. Defaults to no\n",
      "           bounds. Each array must match the size of `x0` or be a scalar,\n",
      "           in the latter case a bound will be the same for all variables.\n",
      "           Use ``np.inf`` with an appropriate sign to disable bounds on all\n",
      "           or some variables.\n",
      "\n",
      "    method : {'trf', 'dogbox', 'lm'}, optional\n",
      "        Algorithm to perform minimization.\n",
      "\n",
      "        * 'trf' : Trust Region Reflective algorithm, particularly suitable\n",
      "          for large sparse problems with bounds. Generally robust method.\n",
      "        * 'dogbox' : dogleg algorithm with rectangular trust regions,\n",
      "          typical use case is small problems with bounds. Not recommended\n",
      "          for problems with rank-deficient Jacobian.\n",
      "        * 'lm' : Levenberg-Marquardt algorithm as implemented in MINPACK.\n",
      "          Doesn't handle bounds and sparse Jacobians. Usually the most\n",
      "          efficient method for small unconstrained problems.\n",
      "\n",
      "        Default is 'trf'. See Notes for more information.\n",
      "    ftol : float or None, optional\n",
      "        Tolerance for termination by the change of the cost function. Default\n",
      "        is 1e-8. The optimization process is stopped when ``dF < ftol * F``,\n",
      "        and there was an adequate agreement between a local quadratic model and\n",
      "        the true model in the last step.\n",
      "\n",
      "        If None and 'method' is not 'lm', the termination by this condition is\n",
      "        disabled. If 'method' is 'lm', this tolerance must be higher than\n",
      "        machine epsilon.\n",
      "    xtol : float or None, optional\n",
      "        Tolerance for termination by the change of the independent variables.\n",
      "        Default is 1e-8. The exact condition depends on the `method` used:\n",
      "\n",
      "        * For 'trf' and 'dogbox' : ``norm(dx) < xtol * (xtol + norm(x))``.\n",
      "        * For 'lm' : ``Delta < xtol * norm(xs)``, where ``Delta`` is\n",
      "          a trust-region radius and ``xs`` is the value of ``x``\n",
      "          scaled according to `x_scale` parameter (see below).\n",
      "\n",
      "        If None and 'method' is not 'lm', the termination by this condition is\n",
      "        disabled. If 'method' is 'lm', this tolerance must be higher than\n",
      "        machine epsilon.\n",
      "    gtol : float or None, optional\n",
      "        Tolerance for termination by the norm of the gradient. Default is 1e-8.\n",
      "        The exact condition depends on a `method` used:\n",
      "\n",
      "        * For 'trf' : ``norm(g_scaled, ord=np.inf) < gtol``, where\n",
      "          ``g_scaled`` is the value of the gradient scaled to account for\n",
      "          the presence of the bounds [STIR]_.\n",
      "        * For 'dogbox' : ``norm(g_free, ord=np.inf) < gtol``, where\n",
      "          ``g_free`` is the gradient with respect to the variables which\n",
      "          are not in the optimal state on the boundary.\n",
      "        * For 'lm' : the maximum absolute value of the cosine of angles\n",
      "          between columns of the Jacobian and the residual vector is less\n",
      "          than `gtol`, or the residual vector is zero.\n",
      "\n",
      "        If None and 'method' is not 'lm', the termination by this condition is\n",
      "        disabled. If 'method' is 'lm', this tolerance must be higher than\n",
      "        machine epsilon.\n",
      "    x_scale : {None, array_like, 'jac'}, optional\n",
      "        Characteristic scale of each variable. Setting `x_scale` is equivalent\n",
      "        to reformulating the problem in scaled variables ``xs = x / x_scale``.\n",
      "        An alternative view is that the size of a trust region along jth\n",
      "        dimension is proportional to ``x_scale[j]``. Improved convergence may\n",
      "        be achieved by setting `x_scale` such that a step of a given size\n",
      "        along any of the scaled variables has a similar effect on the cost\n",
      "        function. If set to 'jac', the scale is iteratively updated using the\n",
      "        inverse norms of the columns of the Jacobian matrix (as described in\n",
      "        [JJMore]_). The default scaling for each method (i.e.\n",
      "        if ``x_scale is None``) is as follows:\n",
      "\n",
      "        * For 'trf'    : ``x_scale == 1``\n",
      "        * For 'dogbox' : ``x_scale == 1``\n",
      "        * For 'lm'     : ``x_scale == 'jac'``\n",
      "\n",
      "        .. versionchanged:: 1.16.0\n",
      "            The default keyword value is changed from 1 to None to indicate that\n",
      "            a default approach to scaling is used.\n",
      "            For the 'lm' method the default scaling is changed from 1 to 'jac'.\n",
      "            This has been found to give better performance, and is the same\n",
      "            scaling as performed by ``leastsq``.\n",
      "\n",
      "    loss : str or callable, optional\n",
      "        Determines the loss function. The following keyword values are allowed:\n",
      "\n",
      "        * 'linear' (default) : ``rho(z) = z``. Gives a standard\n",
      "          least-squares problem.\n",
      "        * 'soft_l1' : ``rho(z) = 2 * ((1 + z)**0.5 - 1)``. The smooth\n",
      "          approximation of l1 (absolute value) loss. Usually a good\n",
      "          choice for robust least squares.\n",
      "        * 'huber' : ``rho(z) = z if z <= 1 else 2*z**0.5 - 1``. Works\n",
      "          similarly to 'soft_l1'.\n",
      "        * 'cauchy' : ``rho(z) = ln(1 + z)``. Severely weakens outliers\n",
      "          influence, but may cause difficulties in optimization process.\n",
      "        * 'arctan' : ``rho(z) = arctan(z)``. Limits a maximum loss on\n",
      "          a single residual, has properties similar to 'cauchy'.\n",
      "\n",
      "        If callable, it must take a 1-D ndarray ``z=f**2`` and return an\n",
      "        array_like with shape (3, m) where row 0 contains function values,\n",
      "        row 1 contains first derivatives and row 2 contains second\n",
      "        derivatives. Method 'lm' supports only 'linear' loss.\n",
      "    f_scale : float, optional\n",
      "        Value of soft margin between inlier and outlier residuals, default\n",
      "        is 1.0. The loss function is evaluated as follows\n",
      "        ``rho_(f**2) = C**2 * rho(f**2 / C**2)``, where ``C`` is `f_scale`,\n",
      "        and ``rho`` is determined by `loss` parameter. This parameter has\n",
      "        no effect with ``loss='linear'``, but for other `loss` values it is\n",
      "        of crucial importance.\n",
      "    diff_step : None or array_like, optional\n",
      "        Determines the relative step size for the finite difference\n",
      "        approximation of the Jacobian. The actual step is computed as\n",
      "        ``x * diff_step``. If None (default), then `diff_step` is taken to be\n",
      "        a conventional \"optimal\" power of machine epsilon for the finite\n",
      "        difference scheme used [NR]_.\n",
      "    tr_solver : {None, 'exact', 'lsmr'}, optional\n",
      "        Method for solving trust-region subproblems, relevant only for 'trf'\n",
      "        and 'dogbox' methods.\n",
      "\n",
      "        * 'exact' is suitable for not very large problems with dense\n",
      "          Jacobian matrices. The computational complexity per iteration is\n",
      "          comparable to a singular value decomposition of the Jacobian\n",
      "          matrix.\n",
      "        * 'lsmr' is suitable for problems with sparse and large Jacobian\n",
      "          matrices. It uses the iterative procedure\n",
      "          `scipy.sparse.linalg.lsmr` for finding a solution of a linear\n",
      "          least-squares problem and only requires matrix-vector product\n",
      "          evaluations.\n",
      "\n",
      "        If None (default), the solver is chosen based on the type of Jacobian\n",
      "        returned on the first iteration.\n",
      "    tr_options : dict, optional\n",
      "        Keyword options passed to trust-region solver.\n",
      "\n",
      "        * ``tr_solver='exact'``: `tr_options` are ignored.\n",
      "        * ``tr_solver='lsmr'``: options for `scipy.sparse.linalg.lsmr`.\n",
      "          Additionally,  ``method='trf'`` supports  'regularize' option\n",
      "          (bool, default is True), which adds a regularization term to the\n",
      "          normal equation, which improves convergence if the Jacobian is\n",
      "          rank-deficient [Byrd]_ (eq. 3.4).\n",
      "\n",
      "    jac_sparsity : {None, array_like, sparse array}, optional\n",
      "        Defines the sparsity structure of the Jacobian matrix for finite\n",
      "        difference estimation, its shape must be (m, n). If the Jacobian has\n",
      "        only few non-zero elements in *each* row, providing the sparsity\n",
      "        structure will greatly speed up the computations [Curtis]_. A zero\n",
      "        entry means that a corresponding element in the Jacobian is identically\n",
      "        zero. If provided, forces the use of 'lsmr' trust-region solver.\n",
      "        If None (default), then dense differencing will be used. Has no effect\n",
      "        for 'lm' method.\n",
      "    max_nfev : None or int, optional\n",
      "        For all methods this parameter controls the maximum number of function\n",
      "        evaluations used by each method, separate to those used in numerical\n",
      "        approximation of the jacobian.\n",
      "        If None (default), the value is chosen automatically as 100 * n.\n",
      "\n",
      "        .. versionchanged:: 1.16.0\n",
      "            The default for the 'lm' method is changed to 100 * n, for both a callable\n",
      "            and a numerically estimated jacobian. Previously the default when using an\n",
      "            estimated jacobian was 100 * n * (n + 1), because the method included\n",
      "            evaluations used in the estimation.\n",
      "\n",
      "    verbose : {0, 1, 2}, optional\n",
      "        Level of algorithm's verbosity:\n",
      "\n",
      "        * 0 (default) : work silently.\n",
      "        * 1 : display a termination report.\n",
      "        * 2 : display progress during iterations (not supported by 'lm'\n",
      "          method).\n",
      "\n",
      "    args, kwargs : tuple and dict, optional\n",
      "        Additional arguments passed to `fun` and `jac`. Both empty by default.\n",
      "        The calling signature is ``fun(x, *args, **kwargs)`` and the same for\n",
      "        `jac`.\n",
      "    callback : None or callable, optional\n",
      "        Callback function that is called by the algorithm on each iteration.\n",
      "        This can be used to print or plot the optimization results at each\n",
      "        step, and to stop the optimization algorithm based on some user-defined\n",
      "        condition.  Only implemented for the `trf` and `dogbox` methods.\n",
      "\n",
      "        The signature is ``callback(intermediate_result: OptimizeResult)``\n",
      "\n",
      "        `intermediate_result is a `scipy.optimize.OptimizeResult`\n",
      "        which contains the intermediate results of the optimization at the\n",
      "        current iteration.\n",
      "\n",
      "        The callback also supports a signature like: ``callback(x)``\n",
      "\n",
      "        Introspection is used to determine which of the signatures is invoked.\n",
      "\n",
      "        If the `callback` function raises `StopIteration` the optimization algorithm\n",
      "        will stop and return with status code -2.\n",
      "\n",
      "        .. versionadded:: 1.16.0\n",
      "    workers : map-like callable, optional\n",
      "        A map-like callable, such as `multiprocessing.Pool.map` for evaluating\n",
      "        any numerical differentiation in parallel.\n",
      "        This evaluation is carried out as ``workers(fun, iterable)``.\n",
      "\n",
      "        .. versionadded:: 1.16.0\n",
      "\n",
      "    Returns\n",
      "    -------\n",
      "    result : OptimizeResult\n",
      "        `OptimizeResult` with the following fields defined:\n",
      "\n",
      "        x : ndarray, shape (n,)\n",
      "            Solution found.\n",
      "        cost : float\n",
      "            Value of the cost function at the solution.\n",
      "        fun : ndarray, shape (m,)\n",
      "            Vector of residuals at the solution.\n",
      "        jac : ndarray, sparse array or LinearOperator, shape (m, n)\n",
      "            Modified Jacobian matrix at the solution, in the sense that J^T J\n",
      "            is a Gauss-Newton approximation of the Hessian of the cost function.\n",
      "            The type is the same as the one used by the algorithm.\n",
      "        grad : ndarray, shape (m,)\n",
      "            Gradient of the cost function at the solution.\n",
      "        optimality : float\n",
      "            First-order optimality measure. In unconstrained problems, it is\n",
      "            always the uniform norm of the gradient. In constrained problems,\n",
      "            it is the quantity which was compared with `gtol` during iterations.\n",
      "        active_mask : ndarray of int, shape (n,)\n",
      "            Each component shows whether a corresponding constraint is active\n",
      "            (that is, whether a variable is at the bound):\n",
      "\n",
      "            *  0 : a constraint is not active.\n",
      "            * -1 : a lower bound is active.\n",
      "            *  1 : an upper bound is active.\n",
      "\n",
      "            Might be somewhat arbitrary for 'trf' method as it generates a\n",
      "            sequence of strictly feasible iterates and `active_mask` is\n",
      "            determined within a tolerance threshold.\n",
      "        nfev : int\n",
      "            Number of function evaluations done. This number does not include\n",
      "            the function calls used for numerical Jacobian approximation.\n",
      "\n",
      "            .. versionchanged:: 1.16.0\n",
      "                For the 'lm' method the number of function calls used in numerical\n",
      "                Jacobian approximation is no longer included. This is to bring all\n",
      "                methods into line.\n",
      "\n",
      "        njev : int or None\n",
      "            Number of Jacobian evaluations done. If numerical Jacobian\n",
      "            approximation is used in 'lm' method, it is set to None.\n",
      "        status : int\n",
      "            The reason for algorithm termination:\n",
      "\n",
      "            * -2 : terminated because callback raised StopIteration.\n",
      "            * -1 : improper input parameters status returned from MINPACK.\n",
      "            *  0 : the maximum number of function evaluations is exceeded.\n",
      "            *  1 : `gtol` termination condition is satisfied.\n",
      "            *  2 : `ftol` termination condition is satisfied.\n",
      "            *  3 : `xtol` termination condition is satisfied.\n",
      "            *  4 : Both `ftol` and `xtol` termination conditions are satisfied.\n",
      "\n",
      "        message : str\n",
      "            Verbal description of the termination reason.\n",
      "        success : bool\n",
      "            True if one of the convergence criteria is satisfied (`status` > 0).\n",
      "\n",
      "    See Also\n",
      "    --------\n",
      "    leastsq : A legacy wrapper for the MINPACK implementation of the\n",
      "              Levenberg-Marquadt algorithm.\n",
      "    curve_fit : Least-squares minimization applied to a curve-fitting problem.\n",
      "\n",
      "    Notes\n",
      "    -----\n",
      "    Method 'lm' (Levenberg-Marquardt) calls a wrapper over a least-squares\n",
      "    algorithm implemented in MINPACK (lmder). It runs the\n",
      "    Levenberg-Marquardt algorithm formulated as a trust-region type algorithm.\n",
      "    The implementation is based on paper [JJMore]_, it is very robust and\n",
      "    efficient with a lot of smart tricks. It should be your first choice\n",
      "    for unconstrained problems. Note that it doesn't support bounds. Also,\n",
      "    it doesn't work when m < n.\n",
      "\n",
      "    Method 'trf' (Trust Region Reflective) is motivated by the process of\n",
      "    solving a system of equations, which constitute the first-order optimality\n",
      "    condition for a bound-constrained minimization problem as formulated in\n",
      "    [STIR]_. The algorithm iteratively solves trust-region subproblems\n",
      "    augmented by a special diagonal quadratic term and with trust-region shape\n",
      "    determined by the distance from the bounds and the direction of the\n",
      "    gradient. This enhancements help to avoid making steps directly into bounds\n",
      "    and efficiently explore the whole space of variables. To further improve\n",
      "    convergence, the algorithm considers search directions reflected from the\n",
      "    bounds. To obey theoretical requirements, the algorithm keeps iterates\n",
      "    strictly feasible. With dense Jacobians trust-region subproblems are\n",
      "    solved by an exact method very similar to the one described in [JJMore]_\n",
      "    (and implemented in MINPACK). The difference from the MINPACK\n",
      "    implementation is that a singular value decomposition of a Jacobian\n",
      "    matrix is done once per iteration, instead of a QR decomposition and series\n",
      "    of Givens rotation eliminations. For large sparse Jacobians a 2-D subspace\n",
      "    approach of solving trust-region subproblems is used [STIR]_, [Byrd]_.\n",
      "    The subspace is spanned by a scaled gradient and an approximate\n",
      "    Gauss-Newton solution delivered by `scipy.sparse.linalg.lsmr`. When no\n",
      "    constraints are imposed the algorithm is very similar to MINPACK and has\n",
      "    generally comparable performance. The algorithm works quite robust in\n",
      "    unbounded and bounded problems, thus it is chosen as a default algorithm.\n",
      "\n",
      "    Method 'dogbox' operates in a trust-region framework, but considers\n",
      "    rectangular trust regions as opposed to conventional ellipsoids [Voglis]_.\n",
      "    The intersection of a current trust region and initial bounds is again\n",
      "    rectangular, so on each iteration a quadratic minimization problem subject\n",
      "    to bound constraints is solved approximately by Powell's dogleg method\n",
      "    [NumOpt]_. The required Gauss-Newton step can be computed exactly for\n",
      "    dense Jacobians or approximately by `scipy.sparse.linalg.lsmr` for large\n",
      "    sparse Jacobians. The algorithm is likely to exhibit slow convergence when\n",
      "    the rank of Jacobian is less than the number of variables. The algorithm\n",
      "    often outperforms 'trf' in bounded problems with a small number of\n",
      "    variables.\n",
      "\n",
      "    Robust loss functions are implemented as described in [BA]_. The idea\n",
      "    is to modify a residual vector and a Jacobian matrix on each iteration\n",
      "    such that computed gradient and Gauss-Newton Hessian approximation match\n",
      "    the true gradient and Hessian approximation of the cost function. Then\n",
      "    the algorithm proceeds in a normal way, i.e., robust loss functions are\n",
      "    implemented as a simple wrapper over standard least-squares algorithms.\n",
      "\n",
      "    .. versionadded:: 0.17.0\n",
      "\n",
      "    References\n",
      "    ----------\n",
      "    .. [STIR] M. A. Branch, T. F. Coleman, and Y. Li, \"A Subspace, Interior,\n",
      "              and Conjugate Gradient Method for Large-Scale Bound-Constrained\n",
      "              Minimization Problems,\" SIAM Journal on Scientific Computing,\n",
      "              Vol. 21, Number 1, pp 1-23, 1999.\n",
      "    .. [NR] William H. Press et. al., \"Numerical Recipes. The Art of Scientific\n",
      "            Computing. 3rd edition\", Sec. 5.7.\n",
      "    .. [Byrd] R. H. Byrd, R. B. Schnabel and G. A. Shultz, \"Approximate\n",
      "              solution of the trust region problem by minimization over\n",
      "              two-dimensional subspaces\", Math. Programming, 40, pp. 247-263,\n",
      "              1988.\n",
      "    .. [Curtis] A. Curtis, M. J. D. Powell, and J. Reid, \"On the estimation of\n",
      "                sparse Jacobian matrices\", Journal of the Institute of\n",
      "                Mathematics and its Applications, 13, pp. 117-120, 1974.\n",
      "    .. [JJMore] J. J. More, \"The Levenberg-Marquardt Algorithm: Implementation\n",
      "                and Theory,\" Numerical Analysis, ed. G. A. Watson, Lecture\n",
      "                Notes in Mathematics 630, Springer Verlag, pp. 105-116, 1977.\n",
      "    .. [Voglis] C. Voglis and I. E. Lagaris, \"A Rectangular Trust Region\n",
      "                Dogleg Approach for Unconstrained and Bound Constrained\n",
      "                Nonlinear Optimization\", WSEAS International Conference on\n",
      "                Applied Mathematics, Corfu, Greece, 2004.\n",
      "    .. [NumOpt] J. Nocedal and S. J. Wright, \"Numerical optimization,\n",
      "                2nd edition\", Chapter 4.\n",
      "    .. [BA] B. Triggs et. al., \"Bundle Adjustment - A Modern Synthesis\",\n",
      "            Proceedings of the International Workshop on Vision Algorithms:\n",
      "            Theory and Practice, pp. 298-372, 1999.\n",
      "\n",
      "    Examples\n",
      "    --------\n",
      "    In this example we find a minimum of the Rosenbrock function without bounds\n",
      "    on independent variables.\n",
      "\n",
      "    >>> import numpy as np\n",
      "    >>> def fun_rosenbrock(x):\n",
      "    ...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])\n",
      "\n",
      "    Notice that we only provide the vector of the residuals. The algorithm\n",
      "    constructs the cost function as a sum of squares of the residuals, which\n",
      "    gives the Rosenbrock function. The exact minimum is at ``x = [1.0, 1.0]``.\n",
      "\n",
      "    >>> from scipy.optimize import least_squares\n",
      "    >>> x0_rosenbrock = np.array([2, 2])\n",
      "    >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)\n",
      "    >>> res_1.x\n",
      "    array([ 1.,  1.])\n",
      "    >>> res_1.cost\n",
      "    9.8669242910846867e-30\n",
      "    >>> res_1.optimality\n",
      "    8.8928864934219529e-14\n",
      "\n",
      "    We now constrain the variables, in such a way that the previous solution\n",
      "    becomes infeasible. Specifically, we require that ``x[1] >= 1.5``, and\n",
      "    ``x[0]`` left unconstrained. To this end, we specify the `bounds` parameter\n",
      "    to `least_squares` in the form ``bounds=([-np.inf, 1.5], np.inf)``.\n",
      "\n",
      "    We also provide the analytic Jacobian:\n",
      "\n",
      "    >>> def jac_rosenbrock(x):\n",
      "    ...     return np.array([\n",
      "    ...         [-20 * x[0], 10],\n",
      "    ...         [-1, 0]])\n",
      "\n",
      "    Putting this all together, we see that the new solution lies on the bound:\n",
      "\n",
      "    >>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,\n",
      "    ...                       bounds=([-np.inf, 1.5], np.inf))\n",
      "    >>> res_2.x\n",
      "    array([ 1.22437075,  1.5       ])\n",
      "    >>> res_2.cost\n",
      "    0.025213093946805685\n",
      "    >>> res_2.optimality\n",
      "    1.5885401433157753e-07\n",
      "\n",
      "    Now we solve a system of equations (i.e., the cost function should be zero\n",
      "    at a minimum) for a Broyden tridiagonal vector-valued function of 100000\n",
      "    variables:\n",
      "\n",
      "    >>> def fun_broyden(x):\n",
      "    ...     f = (3 - x) * x + 1\n",
      "    ...     f[1:] -= x[:-1]\n",
      "    ...     f[:-1] -= 2 * x[1:]\n",
      "    ...     return f\n",
      "\n",
      "    The corresponding Jacobian matrix is sparse. We tell the algorithm to\n",
      "    estimate it by finite differences and provide the sparsity structure of\n",
      "    Jacobian to significantly speed up this process.\n",
      "\n",
      "    >>> from scipy.sparse import lil_array\n",
      "    >>> def sparsity_broyden(n):\n",
      "    ...     sparsity = lil_array((n, n), dtype=int)\n",
      "    ...     i = np.arange(n)\n",
      "    ...     sparsity[i, i] = 1\n",
      "    ...     i = np.arange(1, n)\n",
      "    ...     sparsity[i, i - 1] = 1\n",
      "    ...     i = np.arange(n - 1)\n",
      "    ...     sparsity[i, i + 1] = 1\n",
      "    ...     return sparsity\n",
      "    ...\n",
      "    >>> n = 100000\n",
      "    >>> x0_broyden = -np.ones(n)\n",
      "    ...\n",
      "    >>> res_3 = least_squares(fun_broyden, x0_broyden,\n",
      "    ...                       jac_sparsity=sparsity_broyden(n))\n",
      "    >>> res_3.cost\n",
      "    4.5687069299604613e-23\n",
      "    >>> res_3.optimality\n",
      "    1.1650454296851518e-11\n",
      "\n",
      "    Let's also solve a curve fitting problem using robust loss function to\n",
      "    take care of outliers in the data. Define the model function as\n",
      "    ``y = a + b * exp(c * t)``, where t is a predictor variable, y is an\n",
      "    observation and a, b, c are parameters to estimate.\n",
      "\n",
      "    First, define the function which generates the data with noise and\n",
      "    outliers, define the model parameters, and generate data:\n",
      "\n",
      "    >>> from numpy.random import default_rng\n",
      "    >>> rng = default_rng()\n",
      "    >>> def gen_data(t, a, b, c, noise=0., n_outliers=0, seed=None):\n",
      "    ...     rng = default_rng(seed)\n",
      "    ...\n",
      "    ...     y = a + b * np.exp(t * c)\n",
      "    ...\n",
      "    ...     error = noise * rng.standard_normal(t.size)\n",
      "    ...     outliers = rng.integers(0, t.size, n_outliers)\n",
      "    ...     error[outliers] *= 10\n",
      "    ...\n",
      "    ...     return y + error\n",
      "    ...\n",
      "    >>> a = 0.5\n",
      "    >>> b = 2.0\n",
      "    >>> c = -1\n",
      "    >>> t_min = 0\n",
      "    >>> t_max = 10\n",
      "    >>> n_points = 15\n",
      "    ...\n",
      "    >>> t_train = np.linspace(t_min, t_max, n_points)\n",
      "    >>> y_train = gen_data(t_train, a, b, c, noise=0.1, n_outliers=3)\n",
      "\n",
      "    Define function for computing residuals and initial estimate of\n",
      "    parameters.\n",
      "\n",
      "    >>> def fun(x, t, y):\n",
      "    ...     return x[0] + x[1] * np.exp(x[2] * t) - y\n",
      "    ...\n",
      "    >>> x0 = np.array([1.0, 1.0, 0.0])\n",
      "\n",
      "    Compute a standard least-squares solution:\n",
      "\n",
      "    >>> res_lsq = least_squares(fun, x0, args=(t_train, y_train))\n",
      "\n",
      "    Now compute two solutions with two different robust loss functions. The\n",
      "    parameter `f_scale` is set to 0.1, meaning that inlier residuals should\n",
      "    not significantly exceed 0.1 (the noise level used).\n",
      "\n",
      "    >>> res_soft_l1 = least_squares(fun, x0, loss='soft_l1', f_scale=0.1,\n",
      "    ...                             args=(t_train, y_train))\n",
      "    >>> res_log = least_squares(fun, x0, loss='cauchy', f_scale=0.1,\n",
      "    ...                         args=(t_train, y_train))\n",
      "\n",
      "    And, finally, plot all the curves. We see that by selecting an appropriate\n",
      "    `loss`  we can get estimates close to optimal even in the presence of\n",
      "    strong outliers. But keep in mind that generally it is recommended to try\n",
      "    'soft_l1' or 'huber' losses first (if at all necessary) as the other two\n",
      "    options may cause difficulties in optimization process.\n",
      "\n",
      "    >>> t_test = np.linspace(t_min, t_max, n_points * 10)\n",
      "    >>> y_true = gen_data(t_test, a, b, c)\n",
      "    >>> y_lsq = gen_data(t_test, *res_lsq.x)\n",
      "    >>> y_soft_l1 = gen_data(t_test, *res_soft_l1.x)\n",
      "    >>> y_log = gen_data(t_test, *res_log.x)\n",
      "    ...\n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> plt.plot(t_train, y_train, 'o')\n",
      "    >>> plt.plot(t_test, y_true, 'k', linewidth=2, label='true')\n",
      "    >>> plt.plot(t_test, y_lsq, label='linear loss')\n",
      "    >>> plt.plot(t_test, y_soft_l1, label='soft_l1 loss')\n",
      "    >>> plt.plot(t_test, y_log, label='cauchy loss')\n",
      "    >>> plt.xlabel(\"t\")\n",
      "    >>> plt.ylabel(\"y\")\n",
      "    >>> plt.legend()\n",
      "    >>> plt.show()\n",
      "\n",
      "    In the next example, we show how complex-valued residual functions of\n",
      "    complex variables can be optimized with ``least_squares()``. Consider the\n",
      "    following function:\n",
      "\n",
      "    >>> def f(z):\n",
      "    ...     return z - (0.5 + 0.5j)\n",
      "\n",
      "    We wrap it into a function of real variables that returns real residuals\n",
      "    by simply handling the real and imaginary parts as independent variables:\n",
      "\n",
      "    >>> def f_wrap(x):\n",
      "    ...     fx = f(x[0] + 1j*x[1])\n",
      "    ...     return np.array([fx.real, fx.imag])\n",
      "\n",
      "    Thus, instead of the original m-D complex function of n complex\n",
      "    variables we optimize a 2m-D real function of 2n real variables:\n",
      "\n",
      "    >>> from scipy.optimize import least_squares\n",
      "    >>> res_wrapped = least_squares(f_wrap, (0.1, 0.1), bounds=([0, 0], [1, 1]))\n",
      "    >>> z = res_wrapped.x[0] + res_wrapped.x[1]*1j\n",
      "    >>> z\n",
      "    (0.49999999999925893+0.49999999999925893j)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(scipy.optimize.least_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8f0ddd6",
   "metadata": {},
   "source": [
    "## Exponential fitting\n",
    "As a practical example, we try to fit a given function with a linear combination of exponential with variable exponents. The latter are the nonlinear part. Hence, we have parameters $\\alpha_j, \\beta_j$, and we try to minimize:\n",
    "$$\n",
    "  \\sum_{j = 1}^n | g(\\alpha, \\beta, x_j) - f(x_j)|^2, \\qquad \n",
    "    g(\\alpha, \\beta, x) = \\sum_{i = 1}^k \\alpha_i e^{-\\beta_i x}, \\qquad \n",
    "    f(x) = \\frac{1}{1 + x}\n",
    "$$\n",
    "We can choose the points $x_j$ on a given interval, for instance $[0, 10]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a3752bfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "k = 2\n",
    "n = 100\n",
    "x = np.linspace(0, 10, n)\n",
    "f = lambda x : 1 / (1 + x)\n",
    "y0 = np.array([1.0, 1.0, 1.0, 2.0])\n",
    "\n",
    "def loss(y):\n",
    "    w = np.zeros(n)\n",
    "\n",
    "    alpha = y[0:k]\n",
    "    beta  = y[k:2*k]\n",
    "\n",
    "    for i in range(n):\n",
    "        w[i] = 0.0\n",
    "        for j in range(k):\n",
    "            w[i] = w[i] + alpha[j] * np.exp(-beta[j] * x[i])\n",
    "        w[i] = w[i] - f(x[i])\n",
    "\n",
    "    return w\n",
    "\n",
    "\n",
    "# This approximates the jacobian using finite differences - an explicit computation may be \n",
    "# given using the jac keyword\n",
    "opt = scipy.optimize.least_squares(loss, y0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "15f90861",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.35187538, 0.62481238, 0.14528948, 1.15098591])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a06e7f4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     message: `ftol` termination condition is satisfied.\n",
      "     success: True\n",
      "      status: 2\n",
      "         fun: [-2.331e-02 -5.273e-03 ... -8.227e-03 -8.602e-03]\n",
      "           x: [ 3.519e-01  6.248e-01  1.453e-01  1.151e+00]\n",
      "        cost: 0.0015827620183462155\n",
      "         jac: [[ 1.000e+00  1.000e+00  0.000e+00  0.000e+00]\n",
      "               [ 9.854e-01  8.902e-01 -3.503e-02 -5.619e-02]\n",
      "               ...\n",
      "               [ 2.374e-01  1.127e-05 -8.267e-01 -6.969e-05]\n",
      "               [ 2.339e-01  1.003e-05 -8.230e-01 -6.267e-05]]\n",
      "        grad: [-1.169e-10 -4.313e-11  8.113e-08  4.455e-08]\n",
      "  optimality: 8.113430746085198e-08\n",
      " active_mask: [ 0.000e+00  0.000e+00  0.000e+00  0.000e+00]\n",
      "        nfev: 13\n",
      "        njev: 11\n"
     ]
    }
   ],
   "source": [
    "print(opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "912bbe6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7787539e6660>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def g(t):\n",
    "    y = np.zeros(t.shape)\n",
    "    alpha = opt.x[0:k]\n",
    "    beta  = opt.x[k:2*k]\n",
    "    for j in range(k):\n",
    "        y = y + alpha[j] * np.exp(-beta[j] * t)\n",
    "    return y\n",
    "\n",
    "t = np.linspace(0, 10, 1000)\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(t, f(t), label = \"f(x)\")\n",
    "plt.plot(t, g(t), label = \"g(x)\")\n",
    "plt.title(\"Functions\")\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.title(\"Error\")\n",
    "plt.plot(t, f(t) - g(t), label = \"Error\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4de73a20",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv (3.14.4)",
   "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.14.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
