From 98c811e1cf8c7e72c29f2379aa06ceb42d1b9eb4 Mon Sep 17 00:00:00 2001
From: Egor Danilov <55103065+egorssed@users.noreply.github.com>
Date: Mon, 23 Aug 2021 20:02:27 +0200
Subject: [PATCH 1/4] =?UTF-8?q?=D0=A1=D0=BE=D0=B7=D0=B4=D0=B0=D0=BD=D0=BE?=
 =?UTF-8?q?=20=D1=81=20=D0=BF=D0=BE=D0=BC=D0=BE=D1=89=D1=8C=D1=8E=20Colabo?=
 =?UTF-8?q?ratory?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../GRF_fitting_imperfect_case.ipynb          | 6263 +++++++++++++++++
 1 file changed, 6263 insertions(+)
 create mode 100644 GRF_notebooks/GRF_fitting_imperfect_case.ipynb

diff --git a/GRF_notebooks/GRF_fitting_imperfect_case.ipynb b/GRF_notebooks/GRF_fitting_imperfect_case.ipynb
new file mode 100644
index 0000000..c7caba6
--- /dev/null
+++ b/GRF_notebooks/GRF_fitting_imperfect_case.ipynb
@@ -0,0 +1,6263 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "GRF_fitting_imperfect_case.ipynb",
+      "provenance": [],
+      "collapsed_sections": [
+        "CV4BAYge0GFU",
+        "yKr5aWbhQD_8",
+        "KhzVyjGVSa7y",
+        "0jNY6Ef4Qw23",
+        "BRk6ZMNZSdDi",
+        "UTBJhBM9SjFS",
+        "35uYn8NxCw3O",
+        "NHArYiagUpEY",
+        "Vpn26QPlUYFC",
+        "k_dhaQmgp4G_",
+        "uf5_Pykzi_6R",
+        "wQJOF7jjU-rS",
+        "lF3UWo-yVMwG",
+        "pOpk6BLaVgvD"
+      ],
+      "authorship_tag": "ABX9TyPmcmE1Bio+LusTGSE4HVyP",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/austinpeel/jax-strong-lensing/blob/dev-aym/GRF_notebooks/GRF_fitting_imperfect_case.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "7fsjC3Frkdkb",
+        "outputId": "96fb88fd-7bf7-43f8-97b0-32ef457abaec"
+      },
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "Folder='/content/drive/My Drive/Jax_Strong_Lensing/'\n",
+        "\n",
+        "import sys\n",
+        "sys.path.append(Folder+'/Modules')\n",
+        "_=!python drive/My\\ Drive/Jax_Strong_Lensing/Modules/My_repo/setup.py install"
+      ],
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Mounted at /content/drive\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "25RzDF9-kuYt"
+      },
+      "source": [
+        "# Plotting\n",
+        "import matplotlib.pyplot as plt\n",
+        "import matplotlib as mpl\n",
+        "import seaborn as sns\n",
+        "%matplotlib inline\n",
+        "\n",
+        "\n",
+        "# Basic imports\n",
+        "import numpy as np\n",
+        "from copy import deepcopy\n",
+        "import pandas as pd\n",
+        "from tqdm import tqdm\n",
+        "import math\n",
+        "\n",
+        "#JAX\n",
+        "import jax\n",
+        "import jax.numpy as jnp\n",
+        "from jax.config import config\n",
+        "config.update(\"jax_enable_x64\", True)\n",
+        "config.update(\"jax_debug_nans\", True)\n",
+        "\n",
+        "#Optimizer\n",
+        "from jax.scipy.optimize import minimize as jax_minimize\n",
+        "from scipy.optimize import minimize as scipy_minimize\n",
+        "\n",
+        "#Jaxtronomy\n",
+        "from jaxtronomy.Coordinates.pixel_grid import PixelGrid\n",
+        "from jaxtronomy.Instrument.psf import PSF\n",
+        "from jaxtronomy.Instrument.noise import Noise\n",
+        "from jaxtronomy.LightModel.light_model import LightModel\n",
+        "from jaxtronomy.LensModel.lens_model import LensModel\n",
+        "from jaxtronomy.LensImage.lens_image import LensImage\n",
+        "from jaxtronomy.Parameters.parameters import Parameters\n",
+        "\n",
+        "\n",
+        "\n",
+        "#Jaxified GRF generator\n",
+        "from jaxtronomy.GaussianRandomField.PowerBox_jaxified import get_jaxified_GRF\n",
+        "import jaxtronomy.GaussianRandomField.PowerBox_jaxified as PowerBox_jax\n",
+        "\n",
+        "#Utils for GRF fitting\n",
+        "from jaxtronomy.GaussianRandomField.GRF_fitting import purify_function,get_parameters,get_lens_models,simulate_perturbed_image,simulate_smooth_image,model_loss_function\n",
+        "#Utils for computing axially averaged spectrum\n",
+        "from jaxtronomy.GaussianRandomField.GRF_fitting import Radial_profile,compute_radial_spectrum\n",
+        "#Utils for fitting the GRF\n",
+        "from jaxtronomy.GaussianRandomField.GRF_fitting import GRF_Loss,Spectra_Loss_MSE,Spectra_Loss_MAE\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "# Universal font size\n",
+        "FS = 18"
+      ],
+      "execution_count": 312,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CV4BAYge0GFU"
+      },
+      "source": [
+        "# Theory"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "krwXUDEG0Cdu"
+      },
+      "source": [
+        "Assume that we have GRF perturbed strong lensing event. First, we want to model it without GRF perturbations and consider the residuals.\n",
+        "\n",
+        "## Data\n",
+        "\n",
+        "simulation: $\\psi(\\vec{p}_{0})+\\delta \\psi(A_{0},\\beta_{0},\\phi_{0})$  \n",
+        "model 1: $\\psi(\\vec{p_0})$  \n",
+        "$res_{0}=Im(\\delta \\psi(A_{0},\\beta_{0},\\phi_{0})+\\psi(\\vec{p}_{0})-\\psi(\\vec{p_1}))$\n",
+        "\n",
+        ",where $\\vec{p}$ is a set of source light and unperturbed lens mass parameters and $A_{0},\\beta_{0},\\phi_{0}$ are correpsondingly amplitude,power slope and phase realisation of GRF power spectrum. Index 0 would refer to true values or zeroth aproximation.\n",
+        "\n",
+        "## Model\n",
+        "\n",
+        "mock: $\\psi(\\vec{p}_{0})+\\delta \\psi(A^{i},\\beta^{j},\\phi_{0})$  \n",
+        "model 2: $\\psi(\\vec{p_0})$  \n",
+        "$res^{i,j}=Im(\\delta \\psi(A^{i},\\beta^{j},\\phi^{m})+\\psi(\\vec{p}_{1})-\\psi(\\vec{p_2}))$\n",
+        "\n",
+        ",where we assume that we know the exact lens-source parameters \\vec{p_0}, and exact GRF phase \\phi_{0}\n",
+        "\n",
+        "## Loss\n",
+        "$ PS\\{ res_{0} \\}=|FFT\\{res_{0}*mask\\_ring\\}|^{2} $  \n",
+        "$\\mathcal{L}^{ij}=|| \\ PS\\{res_{0}\\} - PS\\{res^{i,j}\\} \\ ||$\n",
+        "\n",
+        "## Pipeline\n",
+        "\n",
+        "Given lens args $\\vec{p}_{0}$ and GRF's phase $\\phi_{0}$,\n",
+        "\n",
+        "simulate data\n",
+        "\n",
+        "logA,beta -> GRF potential -> perturbed image -> residuals with unperturbed image -> power spectrum of residuals\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "yKr5aWbhQD_8"
+      },
+      "source": [
+        "# Lensing setup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ELPduukaRJRL"
+      },
+      "source": [
+        "#GRF true parameters\n",
+        "GRF_LogAmp=-7.\n",
+        "GRF_beta=2.\n",
+        "GRF_seed=1"
+      ],
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KhzVyjGVSa7y"
+      },
+      "source": [
+        "## Data grids"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ADXViDq1SXpM"
+      },
+      "source": [
+        "npix = 100\n",
+        "pix_scl = 0.08  # arcsec / pixel\n",
+        "half_size = npix * pix_scl / 2\n",
+        "ra_at_xy_0 = dec_at_xy_0 = -half_size + pix_scl / 2\n",
+        "transform_pix2angle = pix_scl * np.eye(2)\n",
+        "kwargs_pixel = {'nx': npix, 'ny': npix,\n",
+        "                'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0,\n",
+        "                'transform_pix2angle': transform_pix2angle}\n",
+        "pixel_grid = PixelGrid(**kwargs_pixel)\n",
+        "xgrid, ygrid = pixel_grid.pixel_coordinates\n",
+        "x_coords = xgrid[0, :]\n",
+        "y_coords = ygrid[:, 0]"
+      ],
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0jNY6Ef4Qw23"
+      },
+      "source": [
+        "## Models"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "RvkYufBtQ35J",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "5a2f1375-cf62-41c2-b54d-b66559d7a7cb"
+      },
+      "source": [
+        "#Source light\n",
+        "source_light_model_list = ['SERSIC_ELLIPSE']\n",
+        "source_light_model = LightModel(source_light_model_list)\n",
+        "kwargs_source_light = [{'amp': 10.0, 'R_sersic': 1.2, 'n_sersic': 1.5, 'center_x': 0.4, 'center_y': 0.15,'e1':0.07,'e2':-0.1}]\n",
+        "\n",
+        "#Lens mass\n",
+        "lens_mass_model_list = ['SIE', 'SHEAR','PIXELATED']\n",
+        "lens_mass_model = LensModel(lens_mass_model_list)\n",
+        "GRF_realisation=get_jaxified_GRF([GRF_LogAmp,GRF_beta],GRF_seed,npix,pix_scl)\n",
+        "kwargs_lens_mass = [{'theta_E': 1.6, 'e1': 0.15, 'e2': -0.04, 'center_x': 0.0, 'center_y': 0.0},\\\n",
+        "                    {'gamma1': -0.01, 'gamma2': 0.03, 'ra_0': 0.0, 'dec_0': 0.0},\\\n",
+        "                    {'x_coords': x_coords, 'y_coords': y_coords, 'psi_grid': GRF_realisation}]\n",
+        "\n",
+        "#Lens light\n",
+        "lens_light_model_list = []\n",
+        "lens_light_model = LightModel(lens_light_model_list)\n",
+        "kwargs_lens_light = [{}]"
+      ],
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BRk6ZMNZSdDi"
+      },
+      "source": [
+        "## Source light model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "5XKVQZMmSb6F"
+      },
+      "source": [
+        "source_light_model_list = ['SERSIC_ELLIPSE']\n",
+        "source_light_model = LightModel(source_light_model_list)\n",
+        "kwargs_source_light = [{'amp': 10.0, 'R_sersic': 1.2, 'n_sersic': 1.5, 'center_x': 0.4, 'center_y': 0.15,'e1':0.07,'e2':-0.1}]"
+      ],
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UTBJhBM9SjFS"
+      },
+      "source": [
+        "## Lens model (SIE + external shear)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "EBPLp82dSg5s"
+      },
+      "source": [
+        "# Lens mass\n",
+        "lens_mass_model_list = ['SIE', 'SHEAR','PIXELATED']\n",
+        "lens_mass_model = LensModel(lens_mass_model_list)\n",
+        "\n",
+        "GRF_realisation=get_jaxified_GRF([GRF_LogAmp,GRF_beta],GRF_seed,npix,pix_scl)\n",
+        "kwargs_lens_mass = [{'theta_E': 1.6, 'e1': 0.15, 'e2': -0.04, 'center_x': 0.0, 'center_y': 0.0},\\\n",
+        "                    {'gamma1': -0.01, 'gamma2': 0.03, 'ra_0': 0.0, 'dec_0': 0.0},\\\n",
+        "                    {'x_coords': x_coords, 'y_coords': y_coords, 'psi_grid': GRF_realisation}]\n",
+        "\n",
+        "# Lens light\n",
+        "lens_light_model_list = []\n",
+        "lens_light_model = LightModel(lens_light_model_list)\n",
+        "kwargs_lens_light = [{}]\n",
+        "\n",
+        "#Combined kwargs smooth\n",
+        "kwargs_data = {'kwargs_lens': kwargs_lens_mass[:-1], 'kwargs_source': kwargs_source_light,'kwargs_lens_light':kwargs_lens_light}\n",
+        "\n",
+        "#Observation conditions and noise\n",
+        "kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': 0.3}\n",
+        "psf = PSF(**kwargs_psf)\n",
+        "kwargs_numerics = {'supersampling_factor': 1}\n",
+        "\n",
+        "kwargs_noise={'background_rms': np.zeros((npix, npix)), 'exposure_time': np.inf}\n",
+        "\n",
+        "#Noiseless models\n",
+        "perturbed_lens_image,smooth_lens_image=get_lens_models(pixel_grid,psf,kwargs_noise,\\\n",
+        "                                                       lens_mass_model_list,source_light_model,lens_light_model,kwargs_numerics)\n",
+        "\n",
+        "perturbed_image=simulate_perturbed_image(GRF_realisation,kwargs_data,perturbed_lens_image,x_coords,y_coords)\n",
+        "unperturbed_image=simulate_smooth_image(kwargs_data,smooth_lens_image)"
+      ],
+      "execution_count": 287,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 495
+        },
+        "id": "ichoKAx0R4IL",
+        "outputId": "81dbcafc-6f13-4d92-f218-743cd1b0a0b5"
+      },
+      "source": [
+        "# Plot\n",
+        "fig, ax = plt.subplots(1, 3, figsize=(15, 7))\n",
+        "\n",
+        "im0=ax[0].imshow(perturbed_image, origin='lower')\n",
+        "ax[0].set_title(\"Perturbed image\", fontsize=FS)\n",
+        "\n",
+        "\n",
+        "im1=ax[1].imshow(unperturbed_image, origin='lower')\n",
+        "ax[1].set_title(\"Unperturbed image\", fontsize=FS)\n",
+        "\n",
+        "\n",
+        "resid_true=perturbed_image-unperturbed_image\n",
+        "im2=ax[2].imshow(resid_true, origin='lower',cmap='seismic',norm=mpl.colors.TwoSlopeNorm(0))\n",
+        "ax[2].set_title(\"Perturbations impact\", fontsize=FS)\n",
+        "\n",
+        "for i,img in enumerate([im0,im1, im2]):\n",
+        "    ax[i].axis('off')\n",
+        "    fig.colorbar(img, ax=ax[i],orientation='horizontal')\n",
+        "\n",
+        "fig.tight_layout()"
+      ],
+      "execution_count": 288,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "35uYn8NxCw3O"
+      },
+      "source": [
+        "## Einstein ring Mask"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "C9hZLeeRCyyt"
+      },
+      "source": [
+        "rmin = 0.5\n",
+        "rmax = 3\n",
+        "radius = np.hypot(xgrid, ygrid)\n",
+        "#Mask covering Einstein ring\n",
+        "mask = ((radius >= rmin) & (radius <= rmax)).astype(bool)\n",
+        "\n",
+        "#There is no sense to consider Fourier space frequncies referring to sizes \n",
+        "#That are bigger than the thickness of the masked region\n",
+        "k_vector=np.fft.fftshift(np.fft.fftfreq(npix,pix_scl))[npix//2:]\n",
+        "#Index from which to consider frequencies\n",
+        "mask_spectral_cut_index=np.where(k_vector>1/(rmax-rmin))[0][0]\n",
+        "masked_k_vector=k_vector[mask_spectral_cut_index:]"
+      ],
+      "execution_count": 9,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 54
+        },
+        "id": "iK0gwiatS9Dd",
+        "outputId": "98635d4b-d2e6-40d9-a344-739cbc750feb"
+      },
+      "source": [
+        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 7))\n",
+        "img1 = ax1.imshow(perturbed_image*mask, origin='lower')\n",
+        "ax1.set_title(\"Perturbed image\", fontsize=FS)\n",
+        "img2 = ax2.imshow(unperturbed_image*mask, origin='lower')\n",
+        "ax2.set_title(\"Unperturbed image\", fontsize=FS)\n",
+        "for img, ax in zip((img1, img2), (ax1, ax2)):\n",
+        "    fig.colorbar(img, ax=ax,orientation='horizontal')\n",
+        "    ax.axis('off')\n",
+        "fig.suptitle('Masked images',y=1.1,fontsize=FS)\n",
+        "fig.tight_layout()"
+      ],
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 720x504 with 4 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "NHArYiagUpEY"
+      },
+      "source": [
+        "## Precompile utility functions"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "o0RKVLn_UsT8"
+      },
+      "source": [
+        "# Precompile the functions with all the arguments that are static for the lensing setup\n",
+        "# So the pure functions depend only on the argument that should be traced\n",
+        "\n",
+        "#Generate GRF\n",
+        "@jax.partial(jax.jit,static_argnums=(1,))\n",
+        "def get_jaxified_GRF_pure(GRF_params,GRF_seed):\n",
+        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
+        "\n",
+        "#Simulate images for kwargs or GRF\n",
+        "simulate_perturbed_image_pure=purify_function(simulate_perturbed_image,kwargs_data,perturbed_lens_image,x_coords,y_coords)\n",
+        "simulate_smooth_image_pure=purify_function(simulate_smooth_image,smooth_lens_image)\n",
+        "\n",
+        "#Get axially averaged spectrum\n",
+        "Radial_profile_pure=purify_function(Radial_profile,(npix,npix))\n",
+        "compute_radial_spectrum_pure=purify_function(compute_radial_spectrum,Radial_profile,mask,mask_spectral_cut_index)"
+      ],
+      "execution_count": 11,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Vpn26QPlUYFC"
+      },
+      "source": [
+        "# Target spectrum, Initial guess"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "x31Be-nCW3kN"
+      },
+      "source": [
+        "#Compute Target Power spectrum of data residuals \n",
+        "resid_true=perturbed_image-unperturbed_image\n",
+        "resid_true_spectrum=compute_radial_spectrum_pure(resid_true)"
+      ],
+      "execution_count": 12,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ptyJj6UaW5Z1"
+      },
+      "source": [
+        "#First assumption is that power spectrum of GRF is close to power spectrum of residuals\n",
+        "#So fit the target power spectrum with a powerlaw to get an initial guess\n",
+        "\n",
+        "def Powerlaw_spectrum(params,masked_k_vector):\n",
+        "  logA,Beta=params\n",
+        "  return np.power(10,logA)*np.power(masked_k_vector,-Beta)\n",
+        "\n",
+        "def GRF_PS_loss(params,masked_k_vector,Target_spectrum):\n",
+        "  logA,Beta=params\n",
+        "  GRF_spectrum=Powerlaw_spectrum(params,masked_k_vector)\n",
+        "  MSE= np.power((Target_spectrum-GRF_spectrum)/Target_spectrum,2)\n",
+        "  return np.mean(MSE)\n",
+        "\n",
+        "#Make a fit\n",
+        "res=scipy_minimize(GRF_PS_loss,x0=[0.,1.],args=(masked_k_vector,resid_true_spectrum))\n",
+        "GRF_init_guess=np.array(res.x)"
+      ],
+      "execution_count": 13,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 320
+        },
+        "id": "KfNmCS07Uc9I",
+        "outputId": "8cee3ac2-a9d9-4d0a-8c72-220f92ef658b"
+      },
+      "source": [
+        "#Plot power spectrum and initial guess\n",
+        "plt.loglog(masked_k_vector,resid_true_spectrum,label='Target spectrum')\n",
+        "plt.loglog(masked_k_vector,Powerlaw_spectrum(GRF_init_guess,masked_k_vector),label='GRF guess')\n",
+        "plt.xlabel('Frequency,' r'$\\frac{1}{arcsec}$',fontsize=FS)\n",
+        "plt.ylabel('Power spectrum',fontsize=FS)\n",
+        "plt.title('Residuals power spectrum and GRF guess',fontsize=FS)\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ],
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEvCAYAAAAQB1WgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hURffHPyedEnoVpPcSepOioggKSFGxvoAiioLt/Ymi2Lvi66u8IoqKWBEFRewISFF6770jUkNPSDu/P+YmLsuG7Ca72U0yn+fZJ9m5c+d+b9k5d2bOnBFVxWKxWCyWUCMs2AIsFovFYvGENVAWi8ViCUmsgbJYLBZLSGINlMVisVhCEmugLBaLxRKSWANlsVgslpDEGigvEBEVkQle5n3GyV8toKL+OZ7X2iyWgoiIXOb8TgYGW4vFN0LeQLk8XK6fUyKyXEQeEpGIYGu0WHIDEWnqvABVC7aW/I6IVBCRF0VkmYgcE5FkETkoIjNF5GERKe2Wf4JbHZXq5P9eRDp4KL+ah3rN9XNT7p1t6JKXKveJwE+AABWA/sAbQH3grgAfuxCQGuBjWCxZ0RR4GpgN7AyqknyMiHQDvgQKA98AnwLHgTJAO+BFYDBQ18Pu9wCngCigIaZu6iYiV6jqXA/5fwM+8ZC+IIenkS/ISwZquap+lv5FRN4BNgJ3ishIVT0UqAOramKgyrYEHhGJBMIL2n0UkXAgWlXPBFtLXkFEGgJTgCNAO1Xd4CFPeeD+TIqYrKqHXfLOAb4DhgOeDNRm13rNci4h38WXGap6GliIaVHVdN0mIhVFZKyI7BaRJBH5S0TGiUg5t3ylROS/IrJNRBJF5IjTpB/ulu+8cR4RCRORx0Rkh7PvWhG51ZNWEZktIjs9pKc3859xK3ekiMwVkb8d/bud8yntXkYmx+suInNE5LCIJDj7fyMidbzYd6ejt7mIzHK6U4+KyMfu18/JX0ZExojIHkfrHud7aZc8VZ3zfNZt31+d9Ifc0heJyAa3NG/vafoYYEMReUNE9gKJQNsLnHOYiDwoIqtF5KSInBCRTSLyoWPcsnttokXkcRFZ5zwjx5wun2Ye8oqIDHbO/ZTzWSMiz6WfF/CRk/13l66gCc72gc73K0XkSRHZ5px3P2e7x7FKl/0u83ANG4jImyKyX0TOiOnequvk6Summz3BuS5e9WL48ny7/j5EpIeILHGu434RGSUeuvdFpJeIrHDy7RGR54FI93wX4DlMy2mQJ+MEoKoHVHWkl+XNdP7W9kGDV4hIaREZL6beOuU8k83EQ33jy/130ouLyKsislVEzorIIRGZKCI13PLFOPdnk/OMHHOe21Fu+bJVJ+WlFpQn0g3T0fQEEamCaR5HAR8C24BamKb35SLSUlWPO9m/BjoB7wKrMV159YHLgHMusAfeAB7AvBX9FygHjAG25/CcojBvW1Mwb16ngVbAIKCDiLRQ1aTMdhaRS4FpwFrgZeAYcBFwJeY6bPZCQ2XMD2sKMBloDtwBtBSRVulv5CJSHJjvlDseWA40w1zrziLSWlVPquouEdkOdMZ0USEiUUAHIM1J/6+TXgxoAbznck6+3NN0PgcSgP8ACuy/wPmOxFRM32OehVSgOnAtEA0kZ+PaRAK/AJdguojeBopjuob+FJFOqrrUpdxPgVuBRZgupGNAPeB64ClMV1NFTJfRS0B65bnN7Vxex1TI7wMngE0XOO+s+BjTXfUSUBb4P+BXEXkSeA0Yi7nvg4D3RGS9qv6RRZnZeb6vAe7F3JvxQC/gYSDe0QaAiPRxyt2JuZ8pwO1Ad29OVkRinLy7VPU3b/bxgvPqKDdiRKSMW1qyh+f5HEQkGpiB6fadACwG4py0zI7lFS6/6yqY670O8+zdCyxyfm+7nOxjMM//J5g6MQJjjDu7lJf9OklVQ/qDMRaK+ZGWwfxQGjsXRoFFbvm/Aw4Cld3SW2Ie2Gec78Wd/d/xQoMCE1y+18VUrDMxXUfp6c2ddAWquaTPBnZ6KLeak/cZlzQBCnnIO8jJ2y8LbW84aeWyeb13Ovs/6Jb+kJM+wiXtRSftXre8Q530513S3geSgMLO905Onk8xFWmEk97TSb/O13vqpD3j7D87vUwvznk5sN7P1yY9ratb3mLAbmC2S1o/l2sR5pY/zOX/gU6+yzxoS9+2Kf0aX+g5uVCZLtfwe0Bc0u930k8AF7ukl8W01iZ6cQ29fr755/dxmnN/T4Kp7Pa7pIU71/UwUMYlvTiwyylnYBbaGjv5vvOwLQZT/7h+Ily2T3D2reNsS6+AV+H5N5J+bp4+C724jvc6eUdmkr7TLd2X+/8W5uWuiVveqs69d61vjgI/ZaE123VSXuriexY4hKmoVmNuxDeYtykgw/L3wFjrRDHdT2WcN5SdwFbgKid7AnAWaCO+e0X1wvxI3lDVDOcJVV2OGfTMNmpIADOGICIlHP2znCxtsigi/c3rOk9dIF5yAnjHLe0dJ72PS1ofzD0Z55b3PSfdNe8szJt9R+d7Z8y9fAuIxbxFA1yOeZh/B5/vqStvqmqKF+cK5ppVEg/eVh7w9trchhkjXeamOQrzjHQQkUJO3vSu4YdVNc21YPfvXjBW/TfmNFqdGsZhnvN3mqruSU9UM/67CS+6sbL5fE9V1Z2uZWCejwoiUtRJbgFcDHykLmNAaloi72aly6GY8/eEh213Yp5p109TD/k2Odv2Ye5zVWC4qro/M+l8B3Rx+9znhdaemJb+W27pH/BPHeAzIiKY53EusM/t2U0fVnH9vR0HGopIowsUm+06KS8ZqHGYm3cN8CjGclfGvLmlUxdzToM4/2E65GwvD6CmG+FBoBGwQ8w4wf9E5AovtKT3w270sG29b6d1PiLST0QWYYxovKM9veuwZBa7vw2swFSaR0XkJxG5X0TK+iBhu7p1s6jqWUeDax90dWCTuyFwvm92y5teAXV2+fs7pvUS75a+SlXTuym8vqdueNOVmc7jmOdonojsE5HPReQWpxvSHW+vTX1MF50nzXdg3vjTu3ZqY1oDB3zQnBm+nHdWuHdXxzt/d3jIGw94O0bq6/Ptqdv8iPM3/Zj++E2mG6ZiHrZN5R8D8ukFyrjOydMX0+0Vi2l9ZcZeVZ3h9lnihdbqwF+qeso10Xk2Pd0fbymLuaZX4fnZ7cK5v7cHMfdsjZix/A+ccUBX25LtOikvjUFtUdUZzv8/i8gfwB+Yt6P0OQPi/P0M03/uiYT0f1T1XRH5DtPvfCmmv3+YiExSVX/OQ8hs0S1Pg7x9gUmYPuUHgD2YyjMcM6ZxwZcKVT0iIq0wLZUumK60/wLPisg1qhoU91VVPSAi6zFjU4Uxb8r3qWqaGE+nK0TkXUw/+n9ddvXpnrrgdStCVReISE2gK6YFdzlwC/CEiHRwMZa+IMAa4N8XyBMIz1NfW08XqgMym1qRWbpkkv5Phuw93xea4pHlMX1gC6ZXpYn7BlXdC+wFyKKlPdelBfetiCQAz4vIMlX92Y9a/YX7/U+/njOAV7PaWVW/c3qgrsHUoVdiXibniciVqpqUkzopLxmoc1DV+SLyKdBfREar6nxMd48CUS7GLKty9mOaxR+Iccv9FLhZRP5zgTeZ9De6epw/SN3AQ/6jmC4Id2p4SPsX5gd7uWtXjYjUy/wszsXpdpztfBCROGAZ8ATeDRjXEJEo15aCMyhbg3PfULcDdUUkwrUV5TTj63D+m+8sTNdsT0xXV7qH00zM4P7VmB/ILJd9fL6n2cF5E53ifBCRezHjnIM412HG22uzBfM2OsuLbrrNQC8RKZ9FKyonq4seBUp5SPf0DAaSHD/fmeD6m3TH02/yPFQ1UUR+BPqKSBf1j6PEY8CNwBsiMt11SCCH7ASuFJGirq0oxzmnOsYRwRVv7/8hZ99iPtShRzEvkJ85XYSvAI9ghkK+dvJkq07KS118nnge83b1HJjWA2Yyb18ROc+tWAxlnf8LO2/yGTgXcbXz1dPNTGcaprL4t2PU0stvjnmDcGczECsirV3yhmEG0t1JdcoOc8krmBuZJR48gsBUnAlc+JxcKYYxJK7c66RPdUmbiqmE73TLO9hJ/9YtfRbmvJ4GdqvqNpf0aMyPOQWX+SK+3NPsksk1W+78db9m3l6bTzATyj22oMTMpUnnc+fva25dI+n3Pp30isjb++jKZqCd6zMvIiUxXm65SY6e7wuwDNPCud31forxCh3iQzlPYVqhH4pI/UzyeN1qU9V4YDTGcN7sg46s+B7T6nzALX0wxjHEHa/uv/My9TnQWkSu93RgcaZUpI8huu2vmO48cJ7TnNRJebYFBaCqW0XkS+BWEemoqvMwrsd/AHNF5BPMxQrDvCn0wlQcz2De8OeIyLcYj6B4zLjBPZg+3HlkgqpuFJExwDBglohMwbiZD8N47bjPcxmHcdH9VkTewnizXY/n6z8Z0489y9EfCfTGzM3whvdFpDIwHeO9VAjzBheL5xnrntgGPO0MfC7DtP7uwDxUo13yvQbcAIxxjPMKzLkPwgwWv+ZW7myMl2N9jNcTAKq6XkT+xrzpLlTVk277eXtPs8sGEVmIcfH+i3/cuZMwEQVc8fbavIXpzhglIp0xRvgExnX3CpxWhHP+X4vIJEx0lNoiMg3zPNbBdDumD0AvwVy/kU7lchrYoaqLvDjHtzFvubOcnocSmMpsF8aQ5hY5fb49oqqpYubTfQUsFpH3MS87d2DGq6p4Wc46EbkOc99Xicg3mCkOJzAvXa0wz9xx/hmTy4q3MC+jT4rIRD+1oj4A7gZeEJFa/ONm3g/T6+Bet/hy/0cC7YGvROQrjGNEEsbh4xrMcz8QU6fsd57XFRinp+qY32s8xohCTuokX93+cvvDP27mD2eyvT7mrex3l7QymG6ZzZiK4BhmPOAtoIGTpzSmH3Slsz3BubFvAhXdjnGeiyamghzpXPCzGCN3K/+46FZzy3+Nc6yzmErwVcwA/zlu5k7ewZiB3UTM/J1xmDcNTzrc3cz7Ylp4e51jHQLm4OK2ncX13okxJM0xlepp52H7FCjvIX9ZzODnXsx8ob2YrrEymZS/zNH8L7f0z530FzPZL8t76uTzeP2zOOcRmFbbQeea7cF0TTTP4bWJwLhmL3HynsZ0/X0OXOXheRqKabmdAU5iWvNPu+Ub4DwbSa73ngu4oLvsO9zled2AqbzP2y+za4iHaREu22bjYSpFJjq8er6zOF5mGvvyz+9sD6aXpQteuJm7lVMRM41iOcYYJTvPxyzMHKzSbvknOMfI7Ll/2dk+wO3c3vZWUya/vQmY7rvTjramwFI8TJvw9v47eQsDT2J+YwnO87gBM12kjZMnyjmvxZiXgLOY38h4oLbbPclWnSROARYLYKIlYCqay4IsJeSw18YS6jhDDocx80O7BVtPTsnrY1AWi8VSIJF/5tG5MgTTfeevSBhBJU+PQVksFksB5n0x4ZnmY7rO2mGmR2zl/MnzeRLbgrJYLJa8yXRM9IwnMWPnl2GcJzro+Y5GeRI7BmWxWCyWkMS2oCwWi8USkhTIMagyZcpotWrVgi3DYrFY8hTLli07rKo5mhjvCwXKQIlIT6BnrVq1WLp0aZb5LRaLxfIPIrIr61z+o0B18anq96p6V/HiniKBWCwWiyWUKFAGymKxWCx5B2ugLBaLxRKSFNgxKIvF4j+Sk5PZu3cviYmJWWe2hDwxMTFUrlyZyMjIoOookPOgWrZsqdZJwmLxHzt27CA2NpbSpUtz7gohlryGqnLkyBFOnjxJ9erVz9nmLLzYMre02C4+i8WSYxITE61xyieICKVLlw6J1rA1UL5QAFubFou3WOOUfwiVe1mgDJSI9BSRccePH89eAYvehW/uhjNH/SvMYrFkmyNHjtC0aVOaNm1KhQoVqFSpUsb3pKQkvx7r2LFjvPPOO34t01teeumloBw3mBQoA5XjeVDJCbB2MrzdCtZ+Y1tUFksIULp0aVauXMnKlSsZMmQIDz30UMb3qKioTPdLSUnx+VihaKBUlbS0tFxWkzsUKAOVYzr+G+6aAyUuhsm3w5e3won9wVZlsVjceP/992nVqhVNmjThuuuu48yZMwAMHDiQIUOG0KZNGx555BG2bdtG27Ztady4MU888QRFixbNKGPUqFG0atWKuLg4nn76aQBGjBjBtm3baNq0KcOHDz/nmKdPn6Z79+40adKERo0aMWnSJACqVavGI488QuPGjWndujVbt24F4NChQ1x33XW0atWKVq1a8eeffwJw6tQpbr/9dho3bkxcXBxTpkxhxIgRJCQk0LRpU2699VZ27txJ3bp16d+/P40aNWLPnj3naJ88eTIDBw7MOOd77rmHtm3bUqNGDWbPns0dd9xB/fr1M/KELNldbjgvf1q0aKE5IiVZ9Y+3VJ8vp/rSxarLPlZNS8tZmRZLHmb9+vXBlqCqqk8//bSOGjVKDx8+nJE2cuRIHT16tKqqDhgwQLt3764pKSmqqtq9e3f94osvVFV17NixWqRIEVVV/fXXX3Xw4MGalpamqamp2r17d50zZ47u2LFDGzZs6PHYkydP1jvvvDPj+7Fjx1RVtWrVqvrCCy+oqurHH3+s3bt3V1XVm2++WefNm6eqqrt27dJ69eqpquojjzyiDzzwQEY5R48eVVXN0KaqumPHDhURXbBgQUaa6/avv/5aBwwYkHHON954o6alpenUqVM1NjZWV69erampqdq8eXNdsWKFx/PxdE+BpZqLdXWBmgflN8IjoP39UK87TLsfpt0Ha76GnqOhVPWs97dY8jHPfr+O9X+d8GuZDS4qxtM9G3qdf+3atTzxxBMcO3aMU6dO0bVr14xtN9xwA+Hh4QAsWLCAqVOnAnDLLbfw8MMPAzB9+nSmT59Os2bNANOq2bJlC1WqVMn0mI0bN+b//u//ePTRR+nRowcdO3bM2HbzzTdn/H3ooYcAmDFjBuvXr8/Ic+LECU6dOsWMGTP48ssvM9JLlizp8XhVq1albdu2Xl2Pnj17IiI0btyY8uXL07hxYwAaNmzIzp07adq0qVfl5DbWQOWE0jVhwPewfAJMfwrGXgKdn4Q2d0NYeLDVWSwFloEDBzJ16lSaNGnChAkTmD17dsa2IkWKZLm/qvLYY49x9913n5O+c+fOTPepU6cOy5cv56effuKJJ57giiuu4KmnngLO9YpL/z8tLY2FCxcSExPjw5n9g/t5uB7D3UU8OjoagLCwsIz/079nZywut7AGygdmbTzAjsNnKBsbTbnYaMo6n9gWtyO1u8IPD8Gvj8HaKdDrbShXP9iSLZZcx5eWTqA4efIkFStWJDk5mc8//5xKlSp5zNe2bVumTJnCjTfeeE6rpWvXrjz55JPceuutFC1alH379hEZGUlsbCwnT3perPavv/6iVKlS3HbbbZQoUYIPPvggY9ukSZMYMWIEkyZNol27dgBcddVV/O9//8sYy1q5ciVNmzalS5cujBkzhjfffBOA+Ph4SpYsSWRkJMnJyZlGdyhfvjwbNmygbt26fPvtt8TGxvp+4UKMAmWgchrq6PtV+/l2xb7z0mMiw4yxKnI/15Rryc1/jyFmbAfW17qbQ03uoUyJWMrFxlC6aBSR4dYvxWIJNM8//zxt2rShbNmytGnTJlOj8uabb3Lbbbfx4osv0q1bN9I9fK+66io2bNiQYUyKFi3KZ599Rs2aNWnfvj2NGjXi6quvZtSoURllrVmzhuHDhxMWFkZkZCRjx47N2BYfH09cXBzR0dFMnDgRgNGjRzN06FDi4uJISUmhU6dOvPvuuzzxxBMMHTqURo0aER4eztNPP03fvn256667iIuLo3nz5rz44ovnncsrr7xCjx49KFu2LC1btuTUqVN+u57BwoY68gFV5XhCModOnuXQybMcdP4eOnWWgycSOXTKfE8+cZAHU8bTK3w+G9Iu5tHku1itNQEoVSTqn9ZX0WjKFnP+xkZTLjYmo1VWLCYiZCbLWSxZsWHDBurXz3s9BmfOnKFQoUKICF9++SUTJ07ku+++8+sxqlWrxtKlSylTpoxfyw00nu5pboc6KlAtqJwiIpQoHEWJwlHULn/h5vPZlL4cWf0DNWc8wncJT7OhWn9mVRjE/jOSYdy2HzrNoVNnSUo5fw5DdEQYZYpGU7JIJCULRzmfSEo4f0sWicpIL+F8LxIVbo2axeIDy5YtY9iwYagqJUqUYPz48cGWZHHBGqgAER0RTnTzXtDgMvjtKRosm0CD43ONp1/1f7x7VJUTCSkcOpX4T4vMpWV27EwyR08nsefoGeLPJHM8ITnTY0aFhxljlW60CkedY+BctxWKCqdwVASFIsMpFBVOochwIsPFGjhLgaJjx46sWrUqoMe4kGOF5cJYAxVoYopDz7eg0XXGJf3jHtDidujyLMQUR0QoXjiS4oUjqVUu60HNlNQ0jickE38mmWNnkog/k0z8mSTiTye5pCURfzqZbYdOEb/LpKWkZd2VGx4mFI4MJ8YxWIWjwomJdPk/KpzCLgatUFQ45YvF0KpaKWqWLWKNm8Vi8SvWQOUW1TvBPfPh9xdh4Tuw+Vfo+SbU6Zr1vi5EhIdRumg0pYtGZ53ZQVU5dTaF+NPGmB1PSOZMUiqJyamcSUolITn9/xQSktJISE4hwUlPz/f3iWSTLymVM8mpJCSlctala7J0kShaVy9Fm+qlaF29NPUqxBIWZg2WxWLJPtZA5SZRhaHri9CwL0wbBl/0g8Y3QLdXoEjgBlBFhNiYSGJjIqlSurDfyk1NU3YdOc3iHUdZvOMoi3Yc5ee1fwNQLCaCVtVKGaNVozQNLypmPRgtFotP5HkDJSI1gJFAcVW9Pth6vKJyCxPT74//wtxRsG0WXP2a6QbMQ91k4WFCjbJFqVG2KDe1NjPs98afYcnOfwzWzI0HASgcFU6LqiVp7RitJheXICbSTma2WCyZE5IGSkTGAz2Ag6rayCW9G/AWEA58oKqvqOp2YJCITA6O2mwSEQWXPQr1e5rW1JRBJlxS9zeguOdJhXmByiULU7lkYfo0qwzAwZOJLNkRz+IdR1i04yhvzNiMKkRFhNH04hJcUrM017eoTOWS/mvZWQomBw4c4KGHHmLhwoWULFmSqKgoHnnkEfr06cPs2bPp1asX1atXJzExkR49evD6668DMGHCBIYPH54xmTcuLo5PPvkkmKdicQhJAwVMAN4GMp4SEQkHxgBdgL3AEhGZpqrrPZaQVyjfAAb9Ztaamvk8vNMWujwHzQdAWN7vEisXG0P3uIp0j6sIwLEzSSzdGc/inaaFNXrmFkbP3ELneuXp364qHWqVsWNXFp9RVXr37s2AAQP44osvANi1axfTpk3LyNOxY0d++OEHEhISaNasGX369KF9+/YA3Hjjjbz99ttB0W7JnJCsAVV1LuC+KmBrYKuqblfVJOBLoFeuiwsEYeHQbijcOx8qNoEfHoRProUj24KtzO+UKBzFlQ3K8/g19fluaHvmPdqZey6ryYrd8fQfv5gr3pjDB/O2c/xM5u70Fos7s2bNIioqiiFDhmSkVa1alfvuu++8vIUKFaJp06bs23d+VJjMyGxZjtmzZ9OjR4+MfMOGDWPChAmAmWN16aWX0qJFC7p27cr+/WZpntGjR9OgQQPi4uK46aabAJgzZ07GIovNmjXLNPJFQSMkDVQmVAL2uHzfC1QSkdIi8i7QTEQey2xnEblLRJaKyNJDhw4FWmv2KFXDBJ/tORr2r4Kx7WH+/yAtNdjKAkalEoUY3rUe8x/rzFs3NaVUkShe+HEDbV6ewaOTV7N2XzZXP7YUKNatW0fz5s29yhsfH8+WLVvo1KlTRtqkSZMyDMRHH3103j4PPPAADzzwAGvWrKFy5cpZHiM5OZn77ruPyZMns2zZMu644w5GjhwJmJBEK1asYPXq1bz77rsAvP7664wZM4aVK1cyb948ChUq5NW55HdCtYvPa1T1CDDEi3zjRGQ/0DMqKqpF4JVlExFoMQBqd4Ef/w+mP2FW7+01xnQH5lOiI8Lp1bQSvZpWYt1fx/ls4S6mrviLSUv30KxKCfq3q8o1jSsSHWEdK0Ken0fA32v8W2aFxnD1K15nHzp0KH/88QdRUVEsWbIEgHnz5tGkSRO2bNnCgw8+SIUKFTLyZ9XFl9myHJmxadMm1q5dS5cuXQBITU2lYkXTzR0XF8ett95K79696d27NwDt27fn3//+N7feeit9+/b1yggWBPJSC2ofcLHL98pOmtdoTpd8z02KXQQ3fQHXj4dju+G9TvD7y5ByNtjKAk7Di4rzct84Fj5+BU/2aMCxM8k8NGkV7V6exau/bGRv/JlgS7SEGA0bNmT58uUZ38eMGcPMmTNx7S1Jjxqxbt06PvzwQ1auXJnj40ZERJyz3Hr6MheqSsOGDTOWnl+zZg3Tp08H4Mcff2To0KEsX76cVq1akZKSwogRI/jggw9ISEigffv2bNy4Mcfa8gW5uTqiLx+gGrDW5XsEsB2oDkQBq4CGPpbZExhXq1at81aKDGlOHVadMlj16WKqb7dR3bMk2IpyldTUNJ27+aAO/niJVh/xg1Yf8YMOmrBEp6/7W88mpwZbnkWDv6JuWlqatm7dWt95552MtF27dmnVqlVVVfX333/PWMlWVfWNN97Qm266SVVVP/roIx06dOgFy7/mmmv0yy+/VFXV9957L2P12t27d2vVqlU1MTFR4+PjtVq1avrRRx/p2bNntWbNmjp//nxVVU1KStK1a9dqamqq7tixIyOtYsWKGh8fr1u3bs041nXXXafffvttzi6IHwiFFXVDsgUlIhOBBUBdEdkrIoNUNQUYBvwKbAC+UtV1vpSreakF5UqR0tB3HNzyFZw9AR9cCb88Dkmng60sVwgLEzrWLsu4/i0znCpW7oln8CdLafvyTJ6Zto7Ve4+lv4RYCiAiwtSpU5kzZw7Vq1endevWDBgwgFdffdVj/iFDhjB37lyv4+S9+eabvPHGG8TFxbF169aMZTkuvvhi+vXrR6NGjejXr1/GCrxRUVFMnjyZRx99lCZNmtC0aVPmz59Pamoqt912G40bN6ZZs2bcf//9lChRgjfffJNGjRoRFyjAfzYAACAASURBVBdHZGQkV199tV+uS16nQC234bIe1OAtW7YEW072SDwBM56BpR9CyWrGoaLGpcFWleskp6Yxb8shpizfx2/rD5CUkkatckXp27wSvZtW4qISdpA5N8mry214S24syxFqhMJyGwXKQKWT3fWgQoqdf8K0++DoNmjeH7o8D4VKBFtVUDiekMxPa/bzzfK9LNkZjwi0q1Gavs0r061RBYpG53lfoJAnvxuoefPmnbcsR3YXPs0rWAMVJPKFgQJIToDZLxtX9CLloMcbUK97sFUFld1HzvDtin18s2Ivu46coVBkON0aVaBv80pcUrMM4XYScEDI7waqIGINVC6TL7r4PLFvuWlNHVhrAtFe/RoULRtsVUFFVVm+O54py/fxw6q/OJGYQvli0VzfojI3tqzi16C5Fmug8iPWQAWJfNOCciU1Gf54E+a+BlFFoNurENcvTwWfDRSJyanM2niQycv2MnvTQdIU2tcqzY2tqnBVg/I2aK0f2LBhA/Xq1bNrguUTVJWNGzdaAxUM8qWBSufgRtOa2rsYal8FPf4Lxe2kv3T2H09g8tK9TFq6h73xCZQoHEmfZpW4qVUV6lbIesFIi2d27NhBbGwspUuXtkYqj6OqHDlyhJMnT1K9evVztuUJAyUihYHSwHlPoqru9oOugJBvu/jcSUuFxe/DzGdBwqHLM9DijnwRfNZfpKUp87cd4cslu5m+7gBJqWk0q1KCm1pdTI+4iyhiHSt8Ijk5mb1792ZMVLXkbWJiYqhcuTKRkZHnpIesgXKiiT8KDAUqZJZPVUO+vyRft6Bcid8J3z8A22dDlUvg2v9BmfzteZQdjp5O4pvle5m0ZA9bDp6iSFQ4PZtcxG1tq9KoUh6bM2exBJBQNlBvAfcBy4E/gHhP+VT1Wb+pCxAFxkABqMLKz+HXx02YpMseg3bDINy2ENwxjhXHmLRkN9+v2k9Cciqd6pTlvs61aFWtVLDlWSxBJ5QN1GFgtuaVVWs9UGC6+Dxx8m8TfHbjD1CxKfR62wTgtHjkRGIyny3cxYfzdnDkdBKtq5fivs616FCrjB1jsRRYQtlAHQeGq+q4wEoKPAWqBeWKKqz/Dn4aDglHocND0Gk4REQHW1nIkpCUysTFuxk3dzt/n0ikSeXiDOtcmyvqlbMLK1oKHKFsoH4GNqnqg4GVFHgKrIFK58xR+HUkrPoCytQ1Y1NV2gRbVUhzNiWVKcv2MXbOVvYcTaBehVjuvbwW3RtXtJN/LQWGUDZQjYGZwGBVzdNBqAq8gUpn6wz4/kE4vhfa3A2dn4ToosFWFdKkpKYxbdVfjPl9K9sOnaZGmSIMuawmvZtWIirCekla8jcha6AARKQXMAX4C9gBuC/1qqp6hf/kBQZroFw4exJmPgeLx0GJKtDzLajZOdiqQp60NOWXdX/z9qytrN9/gnKx0fRvV5Vb2lSlVJGoYMuzWAJCyBooEekOfANEAifI3Iuvuqf0UKBAO0lkxa4FZoLvkS3Q9Dbo+gIUKhlsVSGPqjJn8yHG/7mTuZsPER0RRt/mlbi9fXXqlLcTfy35i1A2UKuBwkAfVfXzes65i21BZUJyIsx5Ff58C4qUge7/gfo9g60qz7DlwEnG/7mTb5bv5WxKGh1rl+GODtW5tHZZ61BhyReEsoFKAB5V1dGBlRR4rIHKgv2r4Luh8PcaaNALrh4FseWDrSrPcPR0EhMX7+bj+Ts5ePIsNcsW4fb21enbvBKFo+z8M0veJZQN1EZgvKq+FlhJgccaKC9ITYb5o2H2qxBZCLq9DE1utsFnfSApJY2f1uznwz92sGbfcWJjIri6UQWubVKJdjVLW+8/S54jlA3UvcCDQHNVPRVQVQHGGigfOLTZjE3tWQg1r4CebxpnCovXqCpLd8UzcbGJ+3fqbAplikbTI64iPZtcRPMqJezkX0ueIJQNVH9gGFAR+AjPXnyo6if+FBgIrIHykbQ0WPKBWWoe4MpnoNWdNvhsNkhMTuX3jQeZtuovZm48SFJKGpVLFqJnk4u4tslF1KsQa42VJWQJZQOV5kU2DeVgsdaLL4cc223mTW2bCRe3NeGSytQOtqo8y8nEZKavO8C0VX/xx9bDpKYpDSoW440bm1CvQrFgy7NYziOUDdSl3uRT1Tk5UpQL2BZUDlCFVRPhl8fMkvOXPQqX3A/hkVnva8mUI6fO8tPavxk9cwsnE5N5uW9j+jSz63hZQouQNVD5CWug/MDJA/DzcBPbr0KcaU1VbBJsVXmegycTGfbFChbvOMptbavwZI8GREeEbKeEpYCR2wbKDiJYskdseej3CfT7FE4dgHGXw4xnzVwqS7YpFxvDF3e24e5La/DZwt30e3cBe+PPBFuWxRIUfOnie8qLbKqqz+dMUuCxLSg/kxAPvz4BKz+D0rXg2rehartgq8rz/LL2b4Z/vYrwcOGtm5pxaZ2ywZZkKeCEbBdfFk4Siln+PaSdJNKxBipAbJtlVvA9thtaDYYrn4ZoG+4nJ+w4fJp7PlvGpgMneeCK2tzfubaNSmEJGqHcxVfdw6c20A2YDiwE6vlboCUPUbMz3LMA2gwxbunvtDMR0y3ZpnqZInx7b3v6NKvEmzO2MHDCEo6dSQq2LIslV/CLk4SYiRtzgXmq+niOC/Tt2EWAd4AkzIq/n2e1j21B5QK7F8G0YXB4s4lA0fUlKGyXTc8uqsrExXt4Zto6apQtwmd3tqFMUbvQpCV3CeUWVKaosXKTgf7+KE9ExovIQRFZ65beTUQ2ichWERnhJPcFJqvqYOBafxzf4geqtIEhf5gVe9d8DWNaw7qpxk3d4jMiwi1tqjB+YCt2HjnNje8t4MAJ65Biyd/404svCijtp7ImYLoOMxCRcGAMcDXQALhZRBoAlYE9TrbzIltYgkhENHR+Au6aDcUqwdcDYNJtcPLvYCvLs3SoXYaPb2/N38cTufG9Bfx1LCHYkiyWgOEXAyUiLYEHgA3+KE9V5wJH3ZJbA1tVdbuqJgFfAr2AvRgjBdZtPjSp0BjunAlXPmvGpMa0hhWf2dZUNmlTozSfDGrDkVNJ9HtvAXuOWjd0S/7E6wpdRLZn8jkGLALKAoEcf6rEPy0lMIapEmYRxetEZCzw/QX03yUiS0Vk6aFDhwIo0+KR8Ajo8CAM+RPKNTTLeXzaG+J3BltZnqRF1ZJ8PrgNJxNTuPG9Bew4fDrYkiwWv+NLi2M3sMvtsxOYAbwK1FXVX/wtMCtU9bSq3q6q91zIQUJVx6lqS1VtWbasnU8SNMrUgoE/msUQ9y4znn4Lx0Ka7Z31lbjKJfhicBsSU9K48b0FbD14MtiSLBa/4rWBUtXLVPVyt09nVb1eVR9X1Z0B1AmwD7jY5XtlJ81rRKSniIw7fvy4X4VZfCQszERDH7oQqraHX0bA+G5wcGOwleU5Gl5UnC/vakuawo3vLWTD/hPBlmSx+A2vDJSIFHU8624ItKALsASoLSLVRSQKuAmY5ksBqvq9qt5VvHjxgAi0+EjxynDr19D3fTiyFd7rCHNGmcUSLV5Tp3wsX93dlsjwMG5+3xopS/7BKwPlLFB4E5ArawCIyERgAVBXRPaKyCBVTcGsR/UrxhnjK1Vd52O5tgUVaohAXD8Yuhjq9YDfX4Bxl8FfK4KtLE9Ro2xRJt3dlpiIcPqPX8yuI3ZMypL38SXU0VLgZ1V9MrCSAo+dqBvCbPwRfvg3nD4Il9wHlz1mlpy3eMWWAye54b0FFIuJZPKQdpQrFhNsSZZ8RChP1H0NuEdE6gRKTKCxLag8QL3uMHQRNLsN/nwLxraHnX8GW1WeoXb5WD4a2IrDp87Sf/xijp+x3aWWvIuv0cz7YCbJ/gBsAdwnYNho5hb/sX22CT4bvxNaDjJLzcfYlWa9Yd6WQ9wxYQlNKpfg00FtKBQV8jGcLXmAvBrNPB0bzdziX5JOw+8vwcJ3ILYi9HgT6lwVbFV5gh9X72fYxOVcVqcs4/q3JDLczmO35IxQ7uLzFM3c/VPD3wL9ie3iy4NEFYGuL8Kg38zSHV/cAFMGw+kjwVYW8nSPq8gLvRvx+6ZDDP96FWlpNnKHJW9hl3y35B1SzsK8N2De6xBTAq55DRr2NZ6AlkwZ8/tWRv26iYGXVOPpng0Qe70s2SRkW1BOWKNMo4WLSA8R2e4fWYHBtqDyOBHRcPljcPdcKFEFJt8BX94CJ/YHW1lIc+9lNRnUoToT5u/k3Tkh/RO1WM7Bly6+akDRC2wvAlTNkZoAYyfq5hPKNzRdfle9YFbxHdMGln1sg89mgogw8pr69GxyEaN+3cjC7bZ71JI38OeoaXnO9+qzWAJDeISZJ3XPfKgYB9/fD59cC0d3BFtZSBIWJrzctzHVShfh/okrOHzqbLAlWSxZcsExKBHpBFzmfH0GEzl8tYespTCRJraoakf/SvQ/dgwqn5GWBss/ht+eMmGSrnjSLDsfFvIOpbnOhv0n6D3mT1pXL8XHt7cmLMyOR1m8J6TczEXkaeBp56sCF3qatwK3qGrI1vwi0hPoWatWrcFbtmwJthyLvzm+D378N2z+BSq1hF5vQ7n6wVYVckxcvJvHvlnD8K51GXp5rWDLseQhQs1AFQdKYAzTduBB4Du3bAqcUlX3BQZDFtuCyseowtop8PMjkHjCLDnf4SGIiAq2spBBVXngy5X8sPovJg5uS5sa/loI25LfCSkDdU5GkUuB9aqa51f7swaqAHD6sFnGY83XUK6BaU1VahFsVSHDqbMp9PzfH5xJSuGn+ztSumh0sCVZ8gAh62YOrAEqZrZRROJEpGTOJVksfqBIGbjuA7j5S0g4Bh9cCb+OhCTrxwNQNDqCMbc0J/5MMg99ZSfxWkITX4PFTrjA9o+Al3OkxmLxN3WvNgsjNh8AC96GsZfAjnnBVhUSNLioGE/3bMDczYcYO2dbsOVYLOfhi4G6HPj+AtunAVfmTE5gsRN1CygxxaHnmzDAeXw/7mGC0Cba5+CW1lXo2eQi/jN9E3M25/nee0s+wxcDdRGw+wLb9zp5QhY7UbeAU72TmTd1yX2w/BMY0xY2/RJsVUFFRHipTyNqli3KwI8W8+KP60lMTg22LIsF8M1AnebCkSKqAnb2nyW0iSpsIlDcOQMKlYSJN8LkQcapooASGxPJ1KHtubVNFd6ft4NrRs9jxe74YMuyWHwyUIuAASIS677BSesPLPaXMIsloFRqAXfNhsseh/XfwZjWsGZygQ2XVCQ6ghd6N+azQW04m5zGdWPn88rPG21ryhJUfDFQrwOVgfkicr2I1HI+1wPznW2jAiHSYgkIEVFw2aMwZB6UrA5TBsHEm8yE3wJKh9pl+OXBjvRreTHvztlGz//9weq9x4Ity1JA8Wm5DRG5G3gLiHTblAw8qKrv+lFbwLDzoCznkZYKi96Fmc9DWARc9Rw0HwhhBXeRv9mbDjJiyhoOnzrLqBvi6NOscrAlWYJMyE7UzdhBpBLQD0iPkbIZmKyqIf/aaUMdWbLk6A4TeHbHXKjWEXq+BaVrBltV0DiekMyQT5exYPsRnuvVkP7tqgVbkiWIhLyByg/YFpTlgqgaL7/pT0LqWbh8JLS910RQL4AkJqcy7IsVzNhwgIevqsPQy2vZRQ8LKKEcSQIAESkiIleKyK0iUj4QoiyWoCICLQaYCb41O8NvT8KHXeDAumArCwoxkeGMva05fZpV4vXpm3nppw0UxBdbS+7jk4ESkXuAfcB04BOgoZNeTkQSRWSw/yVaLEGi2EVw0xdw/UdwbDe81wl+f8ksPV/AiAwP4z83NKF/u6q8P28HI6asIdWGR7IEGF+WfL8OGAP8DtyJy9IbqnoQ+AXo7W+BFktQEYFGfWHYEmh0Hcx51RiqPUuCrSzXCQsTnr22IcMur8WkpXu4b+JyklLSgi3Lko/xpQU1HPhdVftw/pIbAEuBRn5RZbGEGoVLQd9xcMvXcPak6fL75XFIOh1sZbmKiPBw17qMvKY+P635m3s/X8bZFDtXyhIYfDFQjYFvL7B9P1AuZ3IslhCnzlVw70JoeQcsHAPvtIPts4OtKtcZ3KkGz/dqyIwNB7n3s+XWSFkCgi8GKjWL/BdhwiHlKiJSQ0Q+FJHJuX1sSwElphj0eAMG/mTmTH3SC74bZpb1KED8q101nu/diJkbrZGyBAZfDNQqoKunDSISBtwA+NQxLyLjReSgiKx1S+8mIptEZKuIjLhQGaq6XVUH+XJci8UvVGsP9/wJ7R+AlZ/DmDaw8cdgq8pV/tW2Ki84Ruoea6QsfsYXA/U2cLWIPA+USt9fROoCX2M8+kb7ePwJQDfXBBEJxzhjXA00AG4WkQYi0lhEfnD72C5FS3CJLARdnoM7Z5pFEr+8Bb4eCKcOBltZrnFb26q82KcRs6yRsvgZrw2Uqk4CXgJGAhuc5F+A9UAf4FlV/dmXg6vqXOCoW3JrYKvTMkoCvgR6qeoaVe3h9ik4tYAltKnU3ASf7fyEaUWNaQ2rJhWY4LO3tqnKS30aWyNl8Ss+zYNS1SeAlph4fD9j5kO9DbRW1ef8pKkSsMfl+14nzSMiUlpE3gWaichjF8h3l4gsFZGlhw7ZhdksASA8EjoNhyF/QOna8O1d8PkNcGxP1vvmA25pUyXDSL3y88Zgy7HkA3yO3aKqy4HlAdCSLVT1CDDEi3zjgHFgQh0FWpelAFO2LtzxCyx+H2Y+C++0hS7PQos78n3w2VvaVGHzgZN89OdOOtUpy+V1bS+8Jftk69ciIoVFpL7zKexnTfuAi12+V3bScoxd8t2Sa4SFQ9shcO8CqNwSfvw/mNAdDm8NtrKAM+LqetSrEMvwr1dx6GTBi7ph8R++hjpqICI/AceAtc7nmIj8JCIN/aRpCVBbRKqLSBRwEzDNHwXbJd8tuU7JavCvqdBrDBxcB++2hz/ehNSUYCsLGDGR4Yy+uRknE1MYPnmVjdtnyTa+hDpqBizAuJrPwoxDvYUJfXQVZiHDpr4cXEQmOmXWFZG9IjJIVVOAYcCvGGeMr1TVL1E6bQvKEhREoNltMHQx1LoSZjwNH3SGv9cEW1nAqFM+lpHd6zN70yEmzN8ZbDmWPIrXy22IyAygBXCFMw7luq05xmgtUdUuflfpZ+xyG5agsv47+PFhSDgK7R80jhWRMcFW5XdUlTs/Xsq8LYf5blh76lcsFmxJlhwSystttAXedjdOkOE4MQZo5y9hgcC2oCwhQYNeMHQRNO4H816H9zrC7kXBVuV3RITXro+jeOFI7p+4gsRk63pu8Q1fDFQi8PcFtv8FJORMTmCxY1CWkKFwKegzFm6bAskJML4r/PwonD0VbGV+pXTRaP5zQxO2HDzFiz9uyHoHi8UFXwzUT8C1F9h+LWZuVMhiW1CWkKPWlcbTr/VgWPSeCT67bVawVfmVTnXKcmeH6ny6cBdzNts5iBbv8cVA/RsoLSJfi0grEYl1Pq2dQK2lgIcCI9M/2BaUJSSJjoVrRsHtP0NENHzaB6YOhYT4YCvzGw93rUvtckV5dPJqjp9JDrYcSx7BFwN1EGgGXAcsxLiaH8N44fXFOFAcFJFUl0/+9aW1WPxN1XYmCkWHf8OqiSb47Hq/zLAIOjGR4bzRrymHTp3l2e/94pRrKQD4EkniEyBPT2gQkZ5Az1q1agVbisXimcgYuPJpaNgbvhsKX/0L6l8L17wOseWDrS5HNK5cnGGX1+KtmVu4qmEFujWqEGxJlhDHazfz/IR1M7fkCVKTYf5omP2qiZre7WVocrOZV5VHSU5No/eYP/n7eCK/PtSJMkWjgy3J4gOh7GZusVhyk/BI6Ph/ptuvbD2Yeg981hfidwVbWbaJDA/jjX5NOZmYwhPfrrVRJiwXxJdIErVExH3tpjYi8r2I/Ckid/lfnsVioWwd40Bx9SgzX+qddsbjLy0t2MqyRd0Ksfz7qjr8su5vvlv5V7DlWEIYX1pQrwKPpn8RkTIYt/KuQCNgrIj09q88/2LdzC15lrAwaHMXDF0IVdrCz4/AR1fDoc3BVpYtBnesQYuqJXnqu7X8fTwx2HIsIYovBqolMMPl+81AMaA5UBZYBDzgP2n+x7qZW/I8JaqYyb2934VDG03w2bmvm/GqPER4mPCfG5qQlJrGk9/Zrj6LZ3wxUGUx0SLS6Qb8qaprXVa+beBPcRaLxQMi0PRmGLYE6l4Ns56H9y+Hv1YGW5lPVCtThIeurMNv6w/wy9oLBamxFFR8MVCngRIAIhIOdADmumxPwLSoLBZLblC0HPT7BG78DE4dhPc7w4xnTOikPMKgDtVpeFExnpq2juMJeasVaAk8vhiodUB/ESkNDAaKAr+5bK8KhHQcEzsGZcmX1O9pgs82uRn++C+82wF2LQi2Kq+ICA/jlb5xHDl11i4TbzkPXwzUKKAxJqLEGGAFMM9l+1WE0FLwnrBjUJZ8S6GS0HsM/OtbSE2Cj7qZJT3Ongy2sixpXLk4gzpUZ+Li3SzafiTYciwhhNcGSlV/BDoDbwLPAlepM7LptKr2AhMCoNFisXhLzc5wzwJocw8s+cC4pG+ZkfV+QeahLnWoXLIQj327xi7LYcnAp4m6qjpXVf9PVZ9T1aMu6UdUta+qTvW/RIvF4hPRReHqV2DQdIgsDJ9fB98OgTNHs943SBSOiuClPo3Zfug07/y+NdhyLCGCjSRhseRXLm4NQ+ZBp0dgzdcwpjWs+xZC1KW7U52y9GlWibFztrH5QOh3TVoCjzVQFkt+JiIaOo+Eu+ZAsUrw9UCYdBuc2B9sZR55skcDCkdFMOrXTcGWYgkBrIGyWAoCFRrBnTOhy3OwdYZZymP5pyHXmipVJIr+7aoyY8MBdhw+HWw5liBToAyUdTO3FGjCI6D9AzDkT2Owpg2DT3tD/M5gKzuH/u2qERkWxod/bA+2FEuQKVAGyrqZWyxAmVow4Afo/gbsXWY8/RaOhbTQ8J4rGxtN3+aV+HrpXo6cOhtsOZYg4pWBEpEiIvKUiHQNtCCLxZILhIVBq0Em+Gy1DvDLCBjfDQ6GxmTZOztW52xKGp8t3B1sKZYg4pWBUtXTwOPAxYGVY7FYcpXileGWr6Dv+3BkK7zXEeaMCnrw2VrlYulcrxyfLNhp50UVYHzp4tsG2DWaLZb8hgjE9YOhi03YpN9fgHGXwV8rgiprcMcaHDmdxLcr9gVVhyV4+GKg3gEGO1EjLBZLfqNoWbh+PNw0Ec4cMcFnf3sqaMFn29YoReNKxXl/3nbS0kLL29CSO0T4kPckcBTYJCIfA1uAM+6ZVPUTP2mzWCzBoN41UPUSY5z+fAs2fA/X/s+MVeUiIsLgTjW4f+IKZm08yJUNyufq8S3BR7xdKExEvFlfWlU1PGeSfMdZybc7ZrmPD1V1+oXyt2zZUpcuXZor2iyWPM32OfD9/cYVveUdcOWzEJN7q+qkpKZx6ajZVC5ZiEl3t8u141o8IyLLVLVlbh3Ply6+y734dPZVgIiMF5GDIrLWLb2biGwSka0iMuJCZajqVFUdDAwBbvRVg8ViyYQal8I986HtUFg2Ad5pC5sv+P7nVyLCw7i9fTUW7TjKqj3Hcu24ltDA6xZUwASIdAJOAZ+oaiMnLRzYDHTBRElfglliPhx42a2IO1T1oLPff4DPVfWCy37YFpTFkg32LoXvhpql5hv3g26vQJHAD0mfOptC+1dmUa9CLF/e1RYRCfgxLZ4J5RZUBiISLSKVRCQqpwJUdS5mbMuV1sBWVd3uspx8L1Vdo6o93D4HxfAq8HNWxslisWSTyi3h7rlw6QgTdHZMa1g7JeDhkopGR/DY1fVYtOMok5ftDeixLKGFTwZKRJqLyCyMw8RuzLLviEg5EZkpIlf6SVclYI/L971OWmbcB1wJXC8iQzxlEJG7RGSpiCw9dCikF/61WEKXiGi4/DG4ew6UqAKT74Avbwl48Nl+LS+mZdWSvPTTBo6eTgrosSyhg9cGSkSaYlbQrQmc46nndLEVAgb4VZ2XqOpoVW2hqkNU9d1M8ozDLLS4PCoqxw0/i6VgU74h3DkDrnoBtv1ugs8u+zhgramwMOGlvo05mZjCSz9tCMgxLKGHLy2o54C/gIbACMC9I3gmpmvOH+zj3KgVlZ20HGFj8VksfiQsHC65D+75EyrGGW+/T66Fo4EJ8lqnfCx3darB5GV7WbDNLg1fEPDFQHUE3lfVU4Cn16TdwEV+UWWcImqLSHVnnOsmYFpOC7XRzC2WAFC6JvSfBj3fgr9WwjuXwPy3AxJ89r7OtalSqjAjv13D2RQbAim/44uBigEuVLNna3KEiEwEFgB1RWSviAxS1RRgGPArsAH4SlXXZad8V2wLymIJEGFh0GIg3LvQuKZPHwkfdoED6/16mEJR4TzfuxHbD5/m3dl2OY78jq+x+FpcYHtnwOenUVVvVtWKqhqpqpVV9UMn/SdVraOqNVX1RV/L9YRtQVksAaZ4Jbj5S7juQzO5971OMPsVSPGfY8OldcrSs8lFjPl9K9sOnfJbuZbQwxcD9QXwLzdPPQUQkf8DugGf+lGb37EtKIslFxCBxteb4LMNe8Psl2HcpWbtKT/xZI/6xESG8fg3a2ycvnyMLwbqdWAhptttLsY4/VdE9gGvAb9hAspaLBYLFCkD131glvNIPA4fXgm/joSk80J4+ky52Bgeu6Y+i3Yc5etle7LewZIn8dpAORNmuwAPAwlAIlAHOAw8AvRQVW/i9QUN28VnsQSBOl3N2FSLgbDgbRjbDnbMzXGxN7a8mNbVS/Hijxs4eDIx5zotIUfQQx0FAxvqyGIJEjvmwbT7IH6HMVhdnoOY7He5bzt0iqvfmkeXBuUZc0tz/+m0eCRkQx2JSNlACrFYLAWA6h1N8NlL7ofln5gJvpt+znZxNcsW5b7La/Hj6v3M3HDAj0ItoYAvY1AHRGSNiLwlIr1EJM95GtguPoslBIgq7BjwugAAGTNJREFUDFc9D3fOhEKlYOJNJmTS6cPZKu7uS2tSp3xRnpy6llNnU/ws1hJMfDFQozBjT/cC3wKHRWSJiLwqIl1FpHBAFPoR68VnsYQQlZrDXbPh8pGwfhq83QpWf+1zuKSoiDBe7hvH/hOJ/Gf6poBItQQHX5wkHlXV1kBpoDcwBojCOE38BBwVkZyPfFosloJDRBRc+ggMmQelasA3d8IXN8Jx3yKbtahakltaV+GTBbvYcfh0gMRachufl9tQ1ROqOk1VHwRaYhYI3IAxVu39rM+v2C4+iyVEKVcfBk2Hri/DznlmbGrpeEjz3jH4wSvrEB0RZltR+Qhfl9sQEWkpIo+KyK9APDAJKOP8vTsAGv2G7eKzWEKYsHBody/cu8B0//3wEHzcE45s82r3srHRDOpQnR9W72ftPvsSmh/wxYvvW+AIsAgTzTwBeByIU9UKTsiiDwIj02KxFBhKVoP+38G1b8Pfa2DsJfDnaEjN2gFicKcalCgcyahfbSsqP+BLC6oXEAt8BnRQ1d7OOkw5DuJqsVgs5yACzf8FQxdBrSvhtydNJIoDF65uisVEMvSyWszZfMguyZEP8MVAjQRmA9cDq0Vkn4h8JiK3i0jVgKizWCwFm2IV4cbP4IYJcHwvvHcp/P4SpJzNdJd/tatKhWIxvPbrRgpiIIL8hC9efC+rahegJHAF8CFQFXgX2C4i20RkXGBk+gfrJGGx5EFEoGEfE3y28fUw51UTJX3PEo/ZYyL/v707D6+qOvc4/v0lEEIYgkTKLMgggohYqDIoICA4gEOxVmspKIpaqdpbx+pt1Wtxnu4VqlgtDiDSKiIF54pWAZlEEZBRQCahQhiUMXnvH3vHhmOAhOScfU7yfp5nP3rWXnud94RwXtbaa6+VzvW9W/LJ6lzeXugP76ayUi11JKkG0A+4HWgNmJmll1FsceNLHTmXwpa+DZOuh21rodPV0PN2yKi2X5V9efn0eeQD0tPEG9d3Iz0tdgNwdziSdqkjAElVJPWS9CdJ0wkmTbwAHAvMAx6JQ4zOOfcfLU+Ha2bATy6HGSNhZCdY/t5+VSqlp3FD31Ys3biD56evjCRMV3olmcX3HpALvAXcCmQDo4CfAUea2Y/N7Ia4ROmcc4VVqQFnPwiXvg7pGfD8eTDxGtiZ+32VM9vWo0erOtz3xmJWf1P6LT5c4pWkB9UEGAMMBBqYWRszG2Zmr5jZlviE55xzB9GkC1z1IXS9Hua9GDzgu+gfAEhi+PnHUylN3PTyp76xYQoqySSJZmZ2uZmNNbMN8QzKOeeKrXJVOP1OuOJdqFYHXroExg+CHRtpUKsqt53dmhkrNjNm5uqoI3UlVOKljgAk5YQrSnSUlFPWQcWLz+JzrhxrcCIMfS+YNLF4Cow4CT4dx887NuLUlkdy75RFrNniQ32ppKSTJE6Q9D6wkWBFiY+BjZKmSmoXjwDLki915Fw5l14Zut0YDPvltIQJV6KxF3J/7yMAuOXl+f5sVAopySSJtsCHQBdgIjA8PCYSLBL7L0nHxSNI55wrkTqt4LI34Iz7YNU06o85jb+2/ZSPlm3kmY9WRh2dK6ZKJah7F7AX6GpmnxU+ESavD8I6A8ouPOecO0xp6dDpKmh1Jky6jpMWDuetWm25cvJgsqueyQUdGkUdoTuEkgzxdQNGxCYnADP7HBgJdC+rwJxzrkwc0QQGToBzR9KCr3ijyq2smPA/TJ7nkyaSXUkSVDXgYLP31od1nHMuuUhw4iXomlmkterLTZXG0eSVc5jx0XuHvtZFpiQJagXBskYH0i+s45xzyalGXSpdPIad5/2Vhulb6PDWAL76+62wd1fUkbkilCRBPQf0lTRW0nGS0sOjraQxQB9gdFyiPAhJrSU9Ienvkq5O9Ps751JP1fY/JW3YTN7N6EHjz0eS/8QpsPrjqMNyMUqSoB4E/gZcBHwG7AqPT4GLw3MPleTNJT0jaaOkz2PKz5C0WNIySbccrA0zW2RmVwEXkuRbzjvnkkd2Tl1q/+IvDNxzC9t37IBn+sKUm2D3jqhDc6Fiz+Izszzg55L+ApwPNA1PrQBeNbN3DuP9RwOPE/TOAJCUDowATgfWALMkvQakA/fEXH+ZmW2UdA5wNfD8YcTgnKugTjq6Ntlt+9Jj4bF80OFf1Jg5Cha/Dv0fhRa9og6vwivWdhuS6gDNgH+b2fIyDUBqCvzDzNqGrzsDd5hZ3/D1rRDsR1WMtiab2dmHqufbbTjnCqzN3Umvh6bSq3VdRpyyByYOg2+WQvtLoM/dkFU76hCTRlJttyEpTdITBDP0pgFLJH0YJqx4aQh8Vej1mrDsQDH2kPS/kp4EpsQxLudcOdSwVlWu6t6cyZ+tZ8a+lsEqFKf+Dj4dFyw+u3Bi1CFWWIe6BzUMGEowvfwVYD7BShJPxjmuYjOzqWZ2rZldaWYjDlRP0lBJsyXN3rRpUyJDdM4luSu7NadhrarcOWkheelVoNcfYOhUqFEPxv8KXhoI23133kQ7VIL6FbAIaG1mPzOz9gRbvfeXVCtOMa0FGhd63SgsKxUzGwXcCczNyMgobXPOuXKkakY6vz+rNYvWb+O6cZ/wwoxVzNrdiK2XvAm9/ghL3gwWn/1kDPhafglz0HtQkrYDd5nZA4XK2hHsntvJzGaWOoAf3oOqBCwBehEkplnAL8xsQWnfq4Dfg3LOxTIzbn1lPv/4bD07du/7vvxP57flkuZ74LXfwOrp0Lwn9Hs0WKGigkmqe1AEK0OsiylbV+hcqUh6EZgOtJK0RtIQM9tHMLT4JkHvbXxZJSffbsM5dyCSuHdAO+bf0YePbunJXwf/hJOa1ua+178gN6sJDJ4CZz0IX82EkZ3h4ychPz/qsMu1Q/Wg8oFfmtnYQmU5wCagt5n9M/4hlj3vQTnnimPxhu2c+dgHXNb1aG7v1yYozF0Nk66H5e9C405wzv9BnWOiDTRBEt2DKs5zUGdJqlfodRZgwM8ktY+pa2b2SJlFV8Yk9Qf6t2jRIupQnHMpoFW9GlzQoRHPTV/FoC5NaVw7C2odBb98OZjl98Yt8ERX6H4zdL0u2I/KlZni9KBKwswsvXQhxZ/3oJxzxbV+605Oe3AqfY+rx2MXnbj/yR0bYcqNsPBVqHs8nPs4NIj9d3v5kWw9qNMSEoVzziWp+tlVuazr0YycupzLT2nG8Y2CHbnX5e5EqkH9C5+FRZNg8g3wVE/oem3Qo6pcNeLIU1+xVpIoLwoN8V2xdOnSqMNxzqWIbbv20v3+92hWpzqdm+Xw7hcbWbR+GzUzKzHhmq40r1Mddm6Bt/4bPnkecloE96aadIk69DKVbLP4yhUzm2RmQ7Ozs6MOxTmXQmpmVubaXi2Zs2oLf35/OTUyK3Fj31ZUTk/jstGz2PLtHqh6RDDEN/BVyNsLfz0TJv8Odm+POvyUVaF6UAX8HpRzrqTy840ZX35Dm/o1qZUVPOw/Z9VmLn7qY9o3rsULQ04mo1L4b/4938I/74YZf4aaDaH/Y9Cyd4TRlw3vQcWRPwflnDtcaWmiS/Mjv09OAB2a1OaBC9ox88vN/H7CfPLyw3/wZ1SDM+6BIW8F/z9mAEy4Cr7bHFH0qcl7UM45V0qPvL2Ex95dSqU0US87k4a1qtKpWQ5Xdm9GVloefPAgfPhwMAx41gPQ5rxgG/oUk+gelCco55wrJTNj0mfrWbxhG2u37GTV5u/4ZHUu9bMzue3s1px9fH309QKYeA2snwfH9gtWpahZP+rQS8QTVBz5LD7nXKLMWbWZP0xcwIJ12+jSPIdHL2rPj7IqwYwR8N5w8tIyeChtELW7XMrl3ZpHHW6xeIJKAO9BOecSIS/fGDtzNcMnL6J2tQyeHtyRY+vVZPkX88gddzUdWMhH+W1pMPBJjm7ZNupwD8knSTjnXDmRniYGdmrC367qzL78fAaMnMbTH37JgPEbGVb5LlZ1upsT0pZTf0xP8qeNgPw89ubl88T7y5m6eGPU4UfOe1DOOZcAG7buYsizs1iwbhuNjqjK2Ms7cVROFm9Om03l139Hz/R57K3fgZv2DmXCmhpIcEOfVvy6R3OUJBMqfIgvATxBOeei8O3ufYz5eBX9T2hA/exgKSQz44pnZ1Fr+URuT3+WLNvJklZX8YzO5ZVPN9GvXX2u6t6czMrpVK9Sibo1q0SWsDxBxZFPknDOJaMNW3fR55H3aZ61k2cbvELNZROxusfxcsNbuXF62n6b+HZscgTX9z6Gri1yEp6oPEElgPegnHPJZtP23dTIrERm5XT4YgpM/i/Y8TXftBvK3OZX811+ZTZs3cXoaStZv3UXHZscwf0XtKNZnerftzFn1Raa5mSRU70KEPTObn75M/bsy+feAe2CtkvBE1QCeIJyziW9nbnw9h9g7rNQu1mw+GzTU9i9L4/xs9fw8FuLv088JzerzZ2TFjL5s/UcW68GE37dlaoZ6Uyct5brxs0DoNsxdRg1sEOpkpQnqATwBOWcSxkr3odJ18KWldDxMuh9J2TWZF3uToaNncvc1blkZaSzL8/46Y8b8tLsrzj/xIbcdlZrej/8Pk1yqnHRTxpz64T5dG6Ww18GdSQrozh71f5Qsu0H5ZxzLkrNusPV0+C94TBjJCx5E/o9QoNj+vLSlZ15+O0lLNmwnd+f3ZrmdapTt2Ymj727lHmrc9mxex/3X9COY+rWoErlNG7++3zmrNrCqS3rRP2pisV7UM45lyrWzIaJw2DTIjj+QjjjXqiWs1+V/Hzj0tGzeH/JJn7b+xiu693y+3PrcnfSoNbhb6ToQ3xx5LP4nHMpb98e+NdDwZFZE868H9oO2G/x2a079/Lmgg2c177hf7YAKQOeoBLAe1DOuZT39UJ4bRisnQPHnAn9HoaaDeL6lr7UkXPOuUOr2waGvA197oYVU2HEyTDnWShHnQ5PUM45l6rS0qHLb+DX06D+CcFsv2f7w+YVUUdWJjxBOedcqqvdDAZNCraWX/8pjOwC0x6H/LyoIysVT1DOOVceSNBhMFzzMTTrAW/dBk+fHtyrSlGeoJxzrjyp2QAufhEGPA1bVsGT3WDqvcHsvxRTLhKUpGqSZkvqF3UszjkXOQmOvwCumQnHnQ9T74FR3WHNnKgjK5FIE5SkZyRtlPR5TPkZkhZLWibplmI0dTMwPj5ROudciqqWAwOegl+Mh11b4enesPSdqKMqtqiXOhoNPA48V1AgKR0YAZwOrAFmSXoNSAfuibn+MuAEYCGQmYB4nXMu9RzTF349A6aPgKNPjTqaYos0QZnZB5KaxhSfBCwzsxUAksYB55rZPcAPhvAk9QCqAW2AnZKmmFl+PON2zrmUk1kTTrs16ihKJOoeVFEaAl8Ver0GOPlAlc3sNgBJg4F/Hyg5SRoKDAU46qijyipW55xzcVIuJkkAmNloM/vHQc6PMrOOZtaxTp3UWMnXOecqsmRMUGuBxoVeNwrLSk1Sf0mjtm7dWhbNOeeci6NkTFCzgJaSjpaUAVwEvFYWDZvZJDMbmp2dXRbNOeeci6Oop5m/CEwHWklaI2mIme0DhgFvAouA8Wa2oIzez3tQzjmXIny7Deecc8Xi223EkfegnHMudVSoBOX3oJxzLnVUyCE+SZuAVYd5eTYQjy5YWbZb2rZKc31Jrz0S+PdhvpcrWrx+RxMpmT5DImNJ9u+XJmaWsOd0KmSCKg1Jo8xsaDK3W9q2SnN9Sa+VNDuRY9oVQbx+RxMpmT5DImNJhe+XRKpQQ3xlZFIKtFvatkpzfbx+Pq74ysOfQTJ9hkTGkgrfLwnjPSgXKe9BOecOxHtQLmqjog7AOZecvAflnHMuKXkPyjnnXFLyBOWccy4pJeN+UK4Ck1QNGAnsAaaa2ZiIQ3LORcR7UC7uJD0jaaOkz2PKz5C0WNIySbeExT8F/m5mVwDnJDxY51zS8ATlEmE0cEbhAknpwAjgTKANcLGkNgT7fxXsqJyXwBidc0nGE5SLOzP7ANgcU3wSsMzMVpjZHmAccC6whiBJgf9+Oleh+ReAi0pD/tNTgiAxNQReAQZI+jMp+vS7c65s+CQJl1TM7Fvg0qjjcM5Fz3tQLiprgcaFXjcKy5xzDvAE5aIzC2gp6WhJGcBFwGsRx+ScSyKeoFzcSXoRmA60krRG0hAz2wcMA94EFgHjzWxBlHE655KLr8XnnHMuKXkPyjnnXFLyBOWccy4peYJyzjmXlDxBOeecS0qeoJxzziUlT1DOOeeSkico55xzSckTlHPOuaTkCco5V2YkXSjpQ0k7JK2MOh6X2jxBOefK0hbgceC2qANxqc+323DOlRkzextA0nlRx+JSn/egXGQk9ZBkBzk6RR2jcy463oNyyeBFYEoR5csSHYhzLnl4gnLJYK6ZvVCSCySlA1XM7Ls4xeSci5gP8bmkJ2lwOOTXW9J/S1oO7AIuDM9XkfR7SQsk7ZKUK2mSpBOLaKuxpPGStkraFtZrLmmlpKkxde8I37dpEe0UVb9YcRT6PD0l3SBpuaTdkpZIGnSAn0GGpJskzZP0XRj/bEnDwvPnh21ecYDrF0haJkkH/kk7l1y8B+WSQZakI2PKdpvZ9piyB4HKwFPANmCxpMrAG0AX4HmCGWTZwBXAR5K6mdlsAEm1gA8Itpp/AlgIdAfeA6qW5gOUJI5Chofv+ySwG7gaGC1pmZl9VKjtDIKNHXsAbwEvECTo44Gfhu81CdgAXBb+fArH1gloA9xmcd4ALuzZVg4PScoEzMx2x/N9XTllZn74EclB8IVrBzjGFao3OCxbDGTFtPHb8FzfmPKawGpgaqGy4WHdS2PqPhqWT40pvyMsb1pE7Ctj2i5JHAWf5xMgo1B5Q4JE9WJMGzeF9YcXEUdaEZ+vTUydp4B9QIME/JkWfLbCx8qof9f8SM3Dh/hcMhgFnB5z3F1EvT/bD+85/RL4Apgj6ciCA8gA3gZOkVTQOzoP+Bp4LqaN+8rgM5QkjgIjzWxPwQszWwssAVrG1LuE4Pmiu2Lf1MzyC718iiAhDCkokFQN+DnwupmtO9wPV1xmNtrMFHM0jff7uvLJh/hcMlhqZu8Uo96SIspaEwyTbTrIdUcCXwHNgFlmllf4pJmtl5Rb3GAPoCRxFFhRRJ1vgCYxZS2BeWa262ABmNmXkt4BBkq6xcz2EtynqwH85RDxO5d0PEG5VFLUjD0B84H/Osh1B0saB3Ow+zWxf3cOJ468ImsFbR2uUcDfgHOAlwl6UxuAyaVo07lIeIJyqW4pUAf4Z8xwV1FWAC0lpRfuRUmqD9Qqov7m8L+1Ce45FdTPBOqz/3NaJYmjpJYAx0qqYoeebDAR2AgMkfQ50BW4z8z2HewiSXGdPFGWzMxnIlYQfg/KpbrngHocoOciqW6hlxOBusCvYqrdfIC2C4YUe8eU/5Yf/t0pSRwlNQY4Ari9iHb3+7IOh/VGA32BP4bFTx/qDYq4b5S0Ryl+ji7FeA/KpbrHCCZVPCCpJ/BPginoRwG9CKZjnxbWvR/4BfCUpA7AAoKZhJ2BfxfR9jsEMwfvkpQDfAmcAnQqon5J4jicz9gfuF3STwimmu8CjgNa8cME+hRwI3Ax8L6ZLY1tMFxpvElpvvAlVTpUz8y50vAelEtpYY/hbOA6giG2O4FHCGaurQDuKVR3C3Aq8CpBL+o+IIsgcXxbRNt5BPdypgK/Ae4lmJXXPbZ+SeI4jM+4B+hD0INqTDCdfDhwEvBKEfWXETzbBQfuPVUH9pvVJylL0jhJa8PtMj6R1LnQ+f6SFkn6o6Q1BM99IamPpOmSvpW0SdIdYXldSWMlbQjbWyTpuPDc+ZJmhQ8zLwiTeuFYimzTVTBRz3P3w49kOIh5rinVD4K1DbcAVYs4146inwerT/Dgb3WCRPwoMLvQ+T8CewmSdZXwGASsJxhSrAz8CDglrD8R+BOQCaQTJNSawJXhz/skgn8kX0wwgaRKeN0B2/SjYh0KfyGcq9DCIa+VZtYj4lBKTVILgqHJkWb2myLO30jwbNWP7SATOsIVKMaYWfPw9UQg18wGha8LHkK+xMx+MEtQ0iLgNeBuC1cFkZRNMNX+HDObWqjuNwS92zUHa9NVLD7E51w5IelkSYOB8cAe4KGi6pnZA2bWPjY5STpL0juS1knaCrxLsBxUgROBlwq97glsOUgiGUTwfNhqSZMltScYTq0OvBoO7+WGz6BlATuL0aarQDxBOVd+XA08QzCMdomZrSzuhZK6htcOB442s2yCe3Vzw/NHEtz/+rjQZTkEw4hFMrOZZnYOwRJOmwju+eUA/zKzWjFHVTP78lBtuorFE5RzgJk1TfXhPTMbbGZpZtbCzH4weeIQTiRIIjOBdEk3EUzwmBue/zGwysy+KXTNXOA4SacpUFdSNwBJAyS1lpRG0DuqC8wBZgMdJPUKr8mU1FlSs0O16SoeT1DOOYCxBAnqa4IksYVgRYuCBHUiQYL5npl9AlxLsIzSDoLkVrCOYGeC6fDbwzbmA3eY2acEkyxGhue+IliUd08x2nQVjE+ScM45l5S8B+Wccy4peYJyzjmXlDxBOeecS0qeoJxzziUlT1DOOeeSkico55xzSckTlHPOuaTkCco551xS8gTlnHMuKf0/ZEiLhdxhHJkAAAAASUVORK5CYII=\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "SkK_gR6WcK3D"
+      },
+      "source": [
+        "# GRF perfect case fitting"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nfAHFVDIeHG2"
+      },
+      "source": [
+        "## MAE loss function"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "6r9BlulUcYoq"
+      },
+      "source": [
+        "#Pick spectrum loss type (weighted MSE or weighted MAE)\n",
+        "Spectra_Loss_pure=purify_function(Spectra_Loss_MAE,resid_true_spectrum)\n",
+        "GRF_Loss_args=(GRF_seed,unperturbed_image,get_jaxified_GRF_pure,simulate_perturbed_image_pure,compute_radial_spectrum_pure,Spectra_Loss_pure)\n",
+        "\n",
+        "#Precompile GRF_Loss \n",
+        "GRF_Loss_pure=purify_function(GRF_Loss,*GRF_Loss_args)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "apvqTFpAd_q_"
+      },
+      "source": [
+        "loss_func=GRF_Loss_pure\n",
+        "grad_loss_func=jax.grad(GRF_Loss_pure)\n",
+        "hess_loss_func=jax.jacfwd(jax.jacrev(loss_func))"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 332
+        },
+        "id": "SMje8iGWeQWi",
+        "outputId": "f03469b8-5d6c-4530-ad70-50b0c74a7813"
+      },
+      "source": [
+        "print('Loss: Guess={:.2f}, True:{:.2f}'.format(loss_func(GRF_init_guess),loss_func([GRF_LogAmp,GRF_beta])))\n",
+        "grad_loss=grad_loss_func(GRF_init_guess)\n",
+        "print('Grad Loss in guess: grad(logA)={:.2f}, grad(Beta)={:.2f}'.format(grad_loss[0],grad_loss[1]))\n",
+        "\n",
+        "hess_loss=hess_loss_func(GRF_init_guess)\n",
+        "sns.heatmap(np.log10(np.abs(hess_loss)),xticklabels=['logA','Beta'],yticklabels=['logA','Beta'],annot=True,fmt='.2f')\n",
+        "plt.title('Log(Abs(Hessian))')"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Loss: Guess=207.09, True:0.00\n",
+            "Grad Loss in guess: grad(logA)=0.14, grad(Beta)=-2.91\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Text(0.5, 1.0, 'Log(Abs(Hessian))')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 72
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "k_dhaQmgp4G_"
+      },
+      "source": [
+        "## Loss function and Grads"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "FgANh5bFp_Dd",
+        "outputId": "0b1ea150-8a80-4696-bae5-07b227dc3b73"
+      },
+      "source": [
+        "GRF_Amps_array=np.linspace(-7.05,-6.95,100)\n",
+        "GRF_Betas_array=np.linspace(1.5,2.5,100)\n",
+        "\n",
+        "GRF_losses_grid=np.zeros((100,100))\n",
+        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
+        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
+        "\n",
+        "for i in tqdm(range(100)):\n",
+        "  for j in range(100):\n",
+        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
+        "    GRF_Betas_grad_grid[i,j]=grad[1]"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 100/100 [08:18<00:00,  4.98s/it]\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 513
+        },
+        "id": "rsryFH7hqJyG",
+        "outputId": "add1b16c-c148-4a78-b4b0-d361baa09ac4"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
+        "\n",
+        "y_labels=np.round(GRF_Amps_array,9)\n",
+        "x_labels=np.round(GRF_Betas_array,2)\n",
+        "\n",
+        "num_ticks = 10\n",
+        "# the index of the position of yticks\n",
+        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
+        "# the content of labels of these yticks\n",
+        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
+        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
+        "\n",
+        "\n",
+        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "ax[1].set_yticks([])\n",
+        "ax[2].set_yticks([])\n",
+        "\n",
+        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
+        "for i in range(3):\n",
+        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
+        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
+        "  ax[i].invert_yaxis()\n",
+        "\n",
+        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
+        "fig.tight_layout()\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hjaibQco6E4Y",
+        "outputId": "bb4907c5-6393-4378-83a7-75c8e2433112"
+      },
+      "source": [
+        "GRF_Amps_array=np.linspace(-10.,-6.,100)\n",
+        "GRF_Betas_array=np.linspace(1.,8.,100)\n",
+        "\n",
+        "GRF_losses_grid=np.zeros((100,100))\n",
+        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
+        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
+        "\n",
+        "for i in tqdm(range(100)):\n",
+        "  for j in range(100):\n",
+        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
+        "    GRF_Betas_grad_grid[i,j]=grad[1]"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 100/100 [08:18<00:00,  4.99s/it]\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "_zSP5ol7IXkc"
+      },
+      "source": [
+        "#Adjust history to heatmaps\n",
+        "def reindex_history(history):\n",
+        "  i_min=np.argmin(np.abs(np.nanmin(history[:,0])-GRF_Amps_array))\n",
+        "  j_min=np.argmin(np.abs(np.nanmin(history[:,1])-GRF_Betas_array))\n",
+        "\n",
+        "  history_x_labels=j_min+(history[:,1]-np.nanmin(history[:,1]))/(GRF_Betas_array[1]-GRF_Betas_array[0])\n",
+        "  history_y_labels=i_min+(history[:,0]-np.nanmin(history[:,0]))/(GRF_Amps_array[1]-GRF_Amps_array[0])\n",
+        "  return history_x_labels,history_y_labels"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Q9PPuCJR9t3i"
+      },
+      "source": [
+        "history_trust_constr_hess=np.load(Folder+'/Images/history_trust-constr_hess.npy',allow_pickle=True)\n",
+        "\n",
+        "history_hess_x_labels,history_hess_y_labels=reindex_history(np.load(Folder+'/Images/history_trust-constr_hess.npy',allow_pickle=True))\n",
+        "history_jac_loose_x_labels,history_jac_loose_y_labels=reindex_history(np.load(Folder+'/Images/history_trust-constr_jac_loose_bounds.npy',allow_pickle=True))\n",
+        "history_jac_tight_x_labels,history_jac_tight_y_labels=reindex_history(np.load(Folder+'/Images/history_trust-constr_jac_tight_bounds.npy',allow_pickle=True))"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 513
+        },
+        "id": "O-fhPpXT6Ny8",
+        "outputId": "4ecbcd3f-0653-474c-d9c3-1feb8064c670"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
+        "\n",
+        "y_labels=np.round(GRF_Amps_array,9)\n",
+        "x_labels=np.round(GRF_Betas_array,2)\n",
+        "\n",
+        "num_ticks = 10\n",
+        "# the index of the position of yticks\n",
+        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
+        "# the content of labels of these yticks\n",
+        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
+        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
+        "\n",
+        "#Loss\n",
+        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "#Fitting\n",
+        "sns.lineplot(ax=ax[0],x=history_hess_x_labels,y=history_hess_y_labels,label='Hessian fitting',color='C0')\n",
+        "#ax[0].lines[0].set_linestyle((0, (1, 4)))\n",
+        "sns.lineplot(ax=ax[0],x=history_jac_loose_x_labels,y=history_jac_loose_y_labels,label='Jac loose bounds fitting',color='black')\n",
+        "#ax[0].lines[1].set_linestyle((0, (3, 5, 1, 5)))\n",
+        "sns.lineplot(ax=ax[0],x=history_jac_tight_x_labels,y=history_jac_tight_y_labels,label='Jac tight bounds fitting',color='C2')\n",
+        "#ax[0].lines[2].set_linestyle((0, (5, 5)))\n",
+        "ax[0].legend(loc='lower left')\n",
+        "\n",
+        "#Grad Amp\n",
+        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "#Grad Beta\n",
+        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "ax[1].set_yticks([])\n",
+        "ax[2].set_yticks([])\n",
+        "\n",
+        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
+        "for i in range(3):\n",
+        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
+        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
+        "  ax[i].invert_yaxis()\n",
+        "  \n",
+        "\n",
+        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
+        "fig.tight_layout()\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uf5_Pykzi_6R"
+      },
+      "source": [
+        "## Optimize"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RQm7dJme6ANL"
+      },
+      "source": [
+        "### with hessian"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "Lo7OP0I7jE50",
+        "outputId": "8d68a2aa-dfc8-4ec2-83da-a0f0c30fac8c"
+      },
+      "source": [
+        "Nfeval = 1\n",
+        "history=np.zeros((0,2))\n",
+        "init_guess=np.array([-1.,GRF_beta])\n",
+        "bounds=((-10., -0.), (1., 10.0))\n",
+        "\n",
+        "def callbackF(Xi,optimizer):\n",
+        "    global Nfeval\n",
+        "    global history\n",
+        "    loss=loss_func(Xi)\n",
+        "    grad=grad_loss_func(Xi)\n",
+        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
+        "    Nfeval += 1\n",
+        "    history=np.append(history,[Xi],axis=0)\n",
+        "\n",
+        "\n",
+        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,hess=hess_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "   1   -0.035741    4.949092    207.091483    0.137991 -2.910105\n",
+            "   2   -0.856198    4.945717    206.986700    0.183442 -0.644057\n",
+            "   3   -5.868589    4.822722    34.358590    87.559386  42.138639\n",
+            "   4   -5.943401    4.010312    11.876488    28.462279  10.283309\n",
+            "   5   -6.262875    3.900018    4.869780    12.916308  3.930109\n",
+            "   6   -6.794334    4.062581    1.249628    3.842801  1.479443\n",
+            "   7   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
+            "   8   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
+            "   9   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
+            "  10   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
+            "  11   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
+            "  12   -7.207761    3.898954    0.360317    0.164798  0.175580\n",
+            "  13   -7.207761    3.898954    0.360317    0.164798  0.175580\n",
+            "  14   -7.221226    3.884089    0.357859   -0.349431 -0.001718\n",
+            "  15   -7.221226    3.884089    0.357859   -0.349431 -0.001718\n",
+            "  16   -7.221226    3.884089    0.357859   -0.349431 -0.001718\n",
+            "  17   -7.211221    3.884629    0.357271    0.157227  0.171996\n",
+            "  18   -7.217842    3.877100    0.356681   -0.351994 -0.000985\n",
+            "  19   -7.207834    3.877620    0.356594    0.155828  0.172378\n",
+            "  20   -7.214412    3.870055    0.355474   -0.354625 -0.000236\n",
+            "  21   -7.214412    3.870055    0.355474   -0.354625 -0.000236\n",
+            "  22   -7.214412    3.870055    0.355474   -0.354625 -0.000236\n",
+            "  23   -7.209407    3.870304    0.355128    0.051017  0.136020\n",
+            "  24   -7.210611    3.865440    0.354555   -0.052266  0.102385\n",
+            "  25   -7.210611    3.865440    0.354555   -0.052266  0.102385\n",
+            "  26   -7.210611    3.865440    0.354555   -0.052266  0.102385\n",
+            "  27   -6.984057    3.471154    0.343855    0.826480  0.394790\n",
+            "  28   -6.984057    3.471154    0.343855    0.826480  0.394790\n",
+            "  29   -7.129605    3.405498    0.338805   -1.410410 -0.162208\n",
+            "  30   -6.971061    3.423410    0.335638    0.801107  0.392919\n",
+            "  31   -7.116065    3.356675    0.326977   -1.440864 -0.143728\n",
+            "  32   -6.957190    3.372225    0.327284    0.984568  0.394245\n",
+            "  33   -7.106979    3.316397    0.319322   -1.559944 -0.155122\n",
+            "  34   -7.106979    3.316397    0.319322   -1.559944 -0.155122\n",
+            "  35   -7.027512    3.324096    0.270569    0.141178  0.249814\n",
+            "  36   -7.027512    3.324096    0.270569    0.141178  0.249814\n",
+            "  37   -7.055146    3.277961    0.262186   -0.284263  0.153181\n",
+            "  38   -7.055146    3.277961    0.262186   -0.284263  0.153181\n",
+            "  39   -7.005833    3.254395    0.256244    0.399160  0.300427\n",
+            "  40   -7.005833    3.254395    0.256244    0.399160  0.300427\n",
+            "  41   -7.043987    3.227996    0.250892   -0.320593  0.164473\n",
+            "  42   -7.001533    3.208769    0.244381    0.287187  0.272370\n",
+            "  43   -7.001533    3.208769    0.244381    0.287187  0.272370\n",
+            "  44   -7.030741    3.183452    0.238945   -0.259249  0.195838\n",
+            "  45   -7.030741    3.183452    0.238945   -0.259249  0.195838\n",
+            "  46   -6.998408    3.162001    0.233696    0.387363  0.223868\n",
+            "  47   -6.998408    3.162001    0.233696    0.387363  0.223868\n",
+            "  48   -7.021224    3.150149    0.229898   -0.155247  0.211181\n",
+            "  49   -6.988518    3.111610    0.227155    0.410162  0.206936\n",
+            "  50   -6.988518    3.111610    0.227155    0.410162  0.206936\n",
+            "  51   -7.012022    3.101088    0.220559    0.014241  0.148117\n",
+            "  52   -7.016014    3.051789    0.214564   -0.194352  0.115170\n",
+            "  53   -7.016014    3.051789    0.214564   -0.194352  0.115170\n",
+            "  54   -7.016014    3.051789    0.214564   -0.194352  0.115170\n",
+            "  55   -6.994602    3.041258    0.212216    0.088964  0.169036\n",
+            "  56   -7.018013    3.001274    0.210611   -0.622044  0.068430\n",
+            "  57   -6.969984    2.997080    0.210312    0.350325  0.210013\n",
+            "  58   -7.012277    2.975084    0.205068   -0.644117  0.077586\n",
+            "  59   -7.012277    2.975084    0.205068   -0.644117  0.077586\n",
+            "  60   -6.988281    2.972775    0.200861    0.049524  0.175178\n",
+            "  61   -6.994996    2.950959    0.197558   -0.056943  0.161650\n",
+            "  62   -6.976329    2.909162    0.190642    0.209220  0.195894\n",
+            "  63   -6.976329    2.909162    0.190642    0.209220  0.195894\n",
+            "  64   -6.994568    2.894574    0.188754   -0.185511  0.156563\n",
+            "  65   -6.975221    2.881323    0.185425    0.094460  0.188218\n",
+            "  66   -6.998034    2.841964    0.182497   -0.717179  0.114774\n",
+            "  67   -6.998034    2.841964    0.182497   -0.717179  0.114774\n",
+            "  68   -6.974263    2.838935    0.177504    0.076290  0.189374\n",
+            "  69   -6.983781    2.818504    0.174190   -0.221376  0.168326\n",
+            "  70   -6.983781    2.818504    0.174190   -0.221376  0.168326\n",
+            "  71   -6.963725    2.806306    0.172787    0.263176  0.204231\n",
+            "  72   -6.983431    2.793633    0.169894   -0.231096  0.170732\n",
+            "  73   -6.983431    2.793633    0.169894   -0.231096  0.170732\n",
+            "  74   -6.963187    2.781740    0.167916    0.253447  0.203712\n",
+            "  75   -6.982687    2.768839    0.165454   -0.240646  0.173258\n",
+            "  76   -6.982687    2.768839    0.165454   -0.240646  0.173258\n",
+            "  77   -6.962278    2.757226    0.163152    0.244305  0.203420\n",
+            "  78   -6.962278    2.757226    0.163152    0.244305  0.203420\n",
+            "  79   -6.981564    2.744098    0.160859   -0.250060  0.175898\n",
+            "  80   -6.981564    2.744098    0.160859   -0.250060  0.175898\n",
+            "  81   -6.961008    2.732743    0.158477    0.235664  0.203350\n",
+            "  82   -6.961008    2.732743    0.158477    0.235664  0.203350\n",
+            "  83   -6.980072    2.719391    0.156100   -0.259400  0.178656\n",
+            "  84   -6.980072    2.719391    0.156100   -0.259400  0.178656\n",
+            "  85   -6.959384    2.708276    0.153876    0.227424  0.203511\n",
+            "  86   -6.978217    2.694698    0.151162   -0.268762  0.181555\n",
+            "  87   -6.978217    2.694698    0.151162   -0.268762  0.181555\n",
+            "  88   -6.957409    2.683809    0.149440    0.311989  0.203453\n",
+            "  89   -6.978263    2.672992    0.147213   -0.276480  0.183541\n",
+            "  90   -6.957349    2.662307    0.145089    0.303736  0.202969\n",
+            "  91   -6.978097    2.651358    0.143172   -0.284279  0.185647\n",
+            "  92   -6.957084    2.640868    0.140820    0.295691  0.202684\n",
+            "  93   -6.977718    2.629781    0.139048   -0.396189  0.184469\n",
+            "  94   -6.955378    2.621866    0.137610    0.368178  0.200461\n",
+            "  95   -6.977117    2.612681    0.135634   -0.402850  0.186835\n",
+            "  96   -6.954757    2.604834    0.134423    0.362112  0.200479\n",
+            "  97   -6.976444    2.595575    0.132204   -0.218839  0.192243\n",
+            "  98   -6.957083    2.582869    0.129202    0.351132  0.199394\n",
+            "  99   -6.957083    2.582869    0.129202    0.351132  0.199394\n",
+            " 100   -6.973769    2.575623    0.127741   -0.227469  0.195328\n",
+            " 101   -6.958679    2.566006    0.125291    0.342937  0.198730\n",
+            " 102   -6.958679    2.566006    0.125291    0.342937  0.198730\n",
+            " 103   -6.974323    2.559119    0.124633   -0.233956  0.196886\n",
+            " 104   -6.960020    2.550238    0.121717    0.257578  0.201363\n",
+            " 105   -6.960020    2.550238    0.121717    0.257578  0.201363\n",
+            " 106   -6.973798    2.542072    0.121133   -0.241216  0.199037\n",
+            " 107   -6.960120    2.533795    0.118413    0.328811  0.198331\n",
+            " 108   -6.960120    2.533795    0.118413    0.328811  0.198331\n",
+            " 109   -6.973841    2.527589    0.118249   -0.247354  0.200742\n",
+            " 110   -6.961043    2.520012    0.115381    0.322474  0.198134\n",
+            " 111   -6.961043    2.520012    0.115381    0.322474  0.198134\n",
+            " 112   -6.961043    2.520012    0.115381    0.322474  0.198134\n",
+            " 113   -6.967411    2.517095    0.114993   -0.148637  0.205148\n",
+            " 114   -6.962648    2.512364    0.113581    0.054147  0.205789\n",
+            " 115   -6.966686    2.500234    0.111405   -0.156395  0.207311\n",
+            " 116   -6.966686    2.500234    0.111405   -0.156395  0.207311\n",
+            " 117   -6.956935    2.490983    0.110905    0.314202  0.200379\n",
+            " 118   -6.969587    2.485041    0.108715   -0.162606  0.207722\n",
+            " 119   -6.969587    2.485041    0.108715   -0.162606  0.207722\n",
+            " 120   -6.959629    2.475990    0.107071    0.305766  0.199672\n",
+            " 121   -6.959629    2.475990    0.107071    0.305766  0.199672\n",
+            " 122   -6.972223    2.469973    0.106026   -0.274184  0.209143\n",
+            " 123   -6.960046    2.463347    0.104419    0.300193  0.199893\n",
+            " 124   -6.960046    2.463347    0.104419    0.300193  0.199893\n",
+            " 125   -6.972592    2.457270    0.103461   -0.280053  0.210840\n",
+            " 126   -6.960362    2.450736    0.101802    0.294692  0.200205\n",
+            " 127   -6.960362    2.450736    0.101802    0.294692  0.200205\n",
+            " 128   -6.972857    2.444596    0.100853   -0.286071  0.212644\n",
+            " 129   -6.960576    2.438153    0.099218    0.289257  0.200609\n",
+            " 130   -6.960576    2.438153    0.099218    0.289257  0.200609\n",
+            " 131   -6.973017    2.431949    0.098197   -0.292244  0.214557\n",
+            " 132   -6.960688    2.425595    0.096664    0.283883  0.201104\n",
+            " 133   -6.973072    2.419323    0.095492   -0.298585  0.216584\n",
+            " 134   -6.960695    2.413056    0.094136    0.278567  0.201692\n",
+            " 135   -6.973020    2.406716    0.092741   -0.199201  0.216363\n",
+            " 136   -6.962192    2.398610    0.090810    0.271322  0.201796\n",
+            " 137   -6.962192    2.398610    0.090810    0.271322  0.201796\n",
+            " 138   -6.973735    2.392552    0.089840   -0.312004  0.220810\n",
+            " 139   -6.961981    2.386816    0.088483    0.266437  0.202537\n",
+            " 140   -6.973465    2.380692    0.087155   -0.212337  0.220082\n",
+            " 141   -6.963035    2.373328    0.085471    0.259908  0.202880\n",
+            " 142   -6.963035    2.373328    0.085471    0.259908  0.202880\n",
+            " 143   -6.974444    2.367123    0.084398   -0.325089  0.225034\n",
+            " 144   -6.962611    2.361544    0.083185    0.255127  0.203802\n",
+            " 145   -6.973953    2.355270    0.081618   -0.225504  0.223942\n",
+            " 146   -6.973953    2.355270    0.081618   -0.225504  0.223942\n",
+            " 147   -6.963322    2.348164    0.080274    0.248854  0.204384\n",
+            " 148   -6.963322    2.348164    0.080274    0.248854  0.204384\n",
+            " 149   -6.974583    2.341805    0.078734   -0.232419  0.225885\n",
+            " 150   -6.974583    2.341805    0.078734   -0.232419  0.225885\n",
+            " 151   -6.963853    2.334832    0.077415    0.242715  0.205092\n",
+            " 152   -6.963853    2.334832    0.077415    0.242715  0.205092\n",
+            " 153   -6.975026    2.328387    0.075793   -0.239487  0.227986\n",
+            " 154   -6.975026    2.328387    0.075793   -0.239487  0.227986\n",
+            " 155   -6.964202    2.321544    0.074600    0.236702  0.205925\n",
+            " 156   -6.975284    2.315009    0.072791   -0.246720  0.230248\n",
+            " 157   -6.975284    2.315009    0.072791   -0.246720  0.230248\n",
+            " 158   -6.964370    2.308293    0.071882    0.321952  0.198711\n",
+            " 159   -6.976511    2.303288    0.070390   -0.252545  0.231723\n",
+            " 160   -6.965522    2.296681    0.069205    0.316248  0.198975\n",
+            " 161   -6.977625    2.291630    0.068016   -0.365118  0.238367\n",
+            " 162   -6.965588    2.286485    0.067194    0.398841  0.191389\n",
+            " 163   -6.978242    2.282504    0.066060   -0.369939  0.239978\n",
+            " 164   -6.966182    2.277410    0.065219    0.394823  0.191615\n",
+            " 165   -6.978824    2.273410    0.064087   -0.374805  0.241630\n",
+            " 166   -6.966743    2.268365    0.063265    0.390862  0.191872\n",
+            " 167   -6.979371    2.264347    0.062096   -0.379717  0.243322\n",
+            " 168   -6.967268    2.259350    0.061330    0.386958  0.192159\n",
+            " 169   -6.979883    2.255314    0.060085   -0.384675  0.245055\n",
+            " 170   -6.967760    2.250365    0.059412    0.383110  0.192475\n",
+            " 171   -6.980360    2.246310    0.058056   -0.389681  0.246829\n",
+            " 172   -6.968218    2.241408    0.057512    0.379317  0.192819\n",
+            " 173   -6.980803    2.237334    0.056006   -0.394733  0.248644\n",
+            " 174   -6.968642    2.232478    0.055629    0.375580  0.193191\n",
+            " 175   -6.981213    2.228385    0.053935   -0.399834  0.250500\n",
+            " 176   -6.969032    2.223576    0.053855    0.664202  0.160221\n",
+            " 177   -6.982338    2.221598    0.052745   -0.512056  0.256922\n",
+            " 178   -6.969726    2.217614    0.052440    0.661413  0.159963\n",
+            " 179   -6.983031    2.215640    0.051575   -0.622093  0.264229\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "error",
+          "ename": "KeyboardInterrupt",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-74-f7865185f425>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mres\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mscipy_minimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_init_guess\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mjac\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrad_loss_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mhess\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mhess_loss_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'trust-constr'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'disp'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcallbackF\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_minimize.py\u001b[0m in \u001b[0;36mminimize\u001b[0;34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[0m\n\u001b[1;32m    620\u001b[0m         return _minimize_trustregion_constr(fun, x0, args, jac, hess, hessp,\n\u001b[1;32m    621\u001b[0m                                             \u001b[0mbounds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconstraints\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 622\u001b[0;31m                                             callback=callback, **options)\n\u001b[0m\u001b[1;32m    623\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mmeth\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'dogleg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    624\u001b[0m         return _minimize_dogleg(fun, x0, args, jac, hess,\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py\u001b[0m in \u001b[0;36m_minimize_trustregion_constr\u001b[0;34m(fun, x0, args, grad, hess, hessp, bounds, constraints, xtol, gtol, barrier_tol, sparse_jacobian, callback, maxiter, verbose, finite_diff_rel_step, initial_constr_penalty, initial_tr_radius, initial_barrier_parameter, initial_barrier_tolerance, factorization_method, disp)\u001b[0m\n\u001b[1;32m    517\u001b[0m             \u001b[0minitial_barrier_tolerance\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    518\u001b[0m             \u001b[0minitial_constr_penalty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial_tr_radius\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 519\u001b[0;31m             factorization_method)\n\u001b[0m\u001b[1;32m    520\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    521\u001b[0m     \u001b[0;31m# Status 3 occurs when the callback function requests termination,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/tr_interior_point.py\u001b[0m in \u001b[0;36mtr_interior_point\u001b[0;34m(fun, grad, lagr_hess, n_vars, n_ineq, n_eq, constr, jac, x0, fun0, grad0, constr_ineq0, jac_ineq0, constr_eq0, jac_eq0, stop_criteria, enforce_feasibility, xtol, state, initial_barrier_parameter, initial_tolerance, initial_penalty, initial_trust_radius, factorization_method)\u001b[0m\n\u001b[1;32m    327\u001b[0m             \u001b[0mconstr0_subprob\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjac0_subprob\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msubprob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_criteria\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    328\u001b[0m             \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial_penalty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrust_radius\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 329\u001b[0;31m             factorization_method, trust_lb, trust_ub, subprob.scaling)\n\u001b[0m\u001b[1;32m    330\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0msubprob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mterminate\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    331\u001b[0m             \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/equality_constrained_sqp.py\u001b[0m in \u001b[0;36mequality_constrained_sqp\u001b[0;34m(fun_and_constr, grad_and_jac, lagr_hess, x0, fun0, grad0, constr0, jac0, stop_criteria, state, initial_penalty, initial_trust_radius, factorization_method, trust_lb, trust_ub, scaling)\u001b[0m\n\u001b[1;32m    206\u001b[0m             \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mLS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m             \u001b[0;31m# Compute Hessian\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m             \u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlagr_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    209\u001b[0m             \u001b[0;31m# Set Flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    210\u001b[0m             \u001b[0mlast_iteration_failed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/tr_interior_point.py\u001b[0m in \u001b[0;36mlagrangian_hessian\u001b[0;34m(self, z, v)\u001b[0m\n\u001b[1;32m    224\u001b[0m         \u001b[0;34m\"\"\"Returns scaled Lagrangian Hessian\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    225\u001b[0m         \u001b[0;31m# Compute Hessian in relation to x and s\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 226\u001b[0;31m         \u001b[0mHx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlagrangian_hessian_x\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    227\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_ineq\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    228\u001b[0m             \u001b[0mS_Hs_S\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlagrangian_hessian_s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/tr_interior_point.py\u001b[0m in \u001b[0;36mlagrangian_hessian_x\u001b[0;34m(self, z, v)\u001b[0m\n\u001b[1;32m    203\u001b[0m         \u001b[0mv_ineq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_eq\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_eq\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_ineq\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    204\u001b[0m         \u001b[0mlagr_hess\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlagr_hess\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 205\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mlagr_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_eq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_ineq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    206\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mlagrangian_hessian_s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, x, v_eq, v_ineq)\u001b[0m\n\u001b[1;32m     49\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_eq\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mempty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_ineq\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mempty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m         \u001b[0mH_objective\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobjective_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0mH_constraints\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstraints_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_eq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_ineq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mhess\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    190\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray_equal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    191\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_x_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 192\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    193\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    194\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36m_update_hess\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    172\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_update_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    173\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH_updated\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 174\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_hess_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    175\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH_updated\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    176\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mupdate_hess\u001b[0;34m()\u001b[0m\n\u001b[1;32m    117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    118\u001b[0m             \u001b[0;32mdef\u001b[0m \u001b[0mupdate_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhess_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    120\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    121\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mhess\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mFD_METHODS\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mhess_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m    113\u001b[0m                 \u001b[0;32mdef\u001b[0m \u001b[0mhess_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    114\u001b[0m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnhev\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0matleast_2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0matleast_2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mjacfun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    964\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_input_dtype_jacfwd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    965\u001b[0m     \u001b[0mpushfwd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 966\u001b[0;31m     \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpushfwd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_std_basis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    967\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_output_dtype_jacfwd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    968\u001b[0m     \u001b[0mexample_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margnums\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    160\u001b[0m     \u001b[0m__tracebackhide__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    164\u001b[0m       \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfiltering_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mbatched_fun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1285\u001b[0m         \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_axes_flat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1286\u001b[0m         \u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mflatten_axes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"vmap out_axes\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_axes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1287\u001b[0;31m     ).call_wrapped(*args_flat)\n\u001b[0m\u001b[1;32m   1288\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1289\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m       \u001b[0;31m# Some transformations yield from inside context managers, so we have to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_jvp\u001b[0;34m(fun, primals, tangents)\u001b[0m\n\u001b[1;32m   1930\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1931\u001b[0m   \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun_nokwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtree_def\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1932\u001b[0;31m   \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tangents\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mad\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjvp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mps_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1933\u001b[0m   return (tree_unflatten(out_tree(), out_primals),\n\u001b[1;32m   1934\u001b[0m           tree_unflatten(out_tree(), out_tangents))\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m       \u001b[0;31m# Some transformations yield from inside context managers, so we have to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mjacfun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1031\u001b[0m     \u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margnums_partial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margnums\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1032\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_input_dtype_jacrev\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_int\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1033\u001b[0;31m     \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpullback\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_vjp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1034\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_output_dtype_jacrev\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1035\u001b[0m     \u001b[0mjac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpullback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_std_basis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_vjp\u001b[0;34m(fun, has_aux, reduce_axes, *primals)\u001b[0m\n\u001b[1;32m   2135\u001b[0m     \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun_nokwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2136\u001b[0m     out_primal, out_vjp = ad.vjp(\n\u001b[0;32m-> 2137\u001b[0;31m         flat_fun, primals_flat, reduce_axes=reduce_axes)\n\u001b[0m\u001b[1;32m   2138\u001b[0m     \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2139\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mvjp\u001b[0;34m(traceable, primals, has_aux, reduce_axes)\u001b[0m\n\u001b[1;32m    113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvjp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    114\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m     \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinearize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m     \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinearize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mlinearize\u001b[0;34m(traceable, *primals, **kwargs)\u001b[0m\n\u001b[1;32m    100\u001b[0m   \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_flatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m   \u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m   \u001b[0mout_primals_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tangents_pvals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m   \u001b[0;32massert\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_primal_pval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_known\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mout_primal_pval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mout_primals_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr\u001b[0;34m(fun, pvals, instantiate)\u001b[0m\n\u001b[1;32m    503\u001b[0m   \u001b[0;32mwith\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_main\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mJaxprTrace\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    504\u001b[0m     \u001b[0mfun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstantiate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 505\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    506\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    507\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m       \u001b[0;31m# Some transformations yield from inside context managers, so we have to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    160\u001b[0m     \u001b[0m__tracebackhide__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    164\u001b[0m       \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfiltering_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mcache_miss\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    406\u001b[0m         \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs_flat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    407\u001b[0m         \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 408\u001b[0;31m         donated_invars=donated_invars, inline=inline)\n\u001b[0m\u001b[1;32m    409\u001b[0m     \u001b[0mout_pytree_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    410\u001b[0m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_pytree_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    316\u001b[0m     new_params = (update_params(params, nz_tangents, nz_tangents_out)\n\u001b[1;32m    317\u001b[0m                   if update_params else params)\n\u001b[0;32m--> 318\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mnonzero_tangents\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mnew_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m     \u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree_def\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    320\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mJVPTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    193\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    194\u001b[0m       jaxpr, out_pvals, consts, env_tracers = self.partial_eval(\n\u001b[0;32m--> 195\u001b[0;31m           f, in_pvals, app, instantiate=False)\n\u001b[0m\u001b[1;32m    196\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap_primitive\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    197\u001b[0m         \u001b[0munmapped_aval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munmapped_aval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'axis_size'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mpartial_eval\u001b[0;34m(self, f, pvals, app, instantiate)\u001b[0m\n\u001b[1;32m    301\u001b[0m     \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstantiate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    302\u001b[0m     \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial_eval_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 303\u001b[0;31m     \u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0min_consts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    304\u001b[0m     \u001b[0mout_consts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msplit_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjaxpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstvars\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    305\u001b[0m     \u001b[0mout_pvs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPartialVal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_consts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    316\u001b[0m     new_params = (update_params(params, nz_tangents, nz_tangents_out)\n\u001b[1;32m    317\u001b[0m                   if update_params else params)\n\u001b[0;32m--> 318\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mnonzero_tangents\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mnew_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m     \u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree_def\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    320\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mJVPTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/batching.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    157\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    158\u001b[0m       \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch_subtrace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 159\u001b[0;31m       \u001b[0mvals_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    160\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mBatchTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvals_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    612\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 613\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    614\u001b[0m   \u001b[0mprocess_map\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_call_impl\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m    618\u001b[0m   \u001b[0;32mdel\u001b[0m \u001b[0minline\u001b[0m  \u001b[0;31m# Only used at tracing time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    619\u001b[0m   compiled_fun = _xla_callable(fun, device, backend, name, donated_invars,\n\u001b[0;32m--> 620\u001b[0;31m                                *unsafe_map(arg_spec, args))\n\u001b[0m\u001b[1;32m    621\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    622\u001b[0m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompiled_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mmemoized_fun\u001b[0;34m(fun, *args)\u001b[0m\n\u001b[1;32m    260\u001b[0m       \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulate_stores\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    261\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 262\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    263\u001b[0m       \u001b[0mcache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mans\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    264\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_callable\u001b[0;34m(fun, device, backend, name, donated_invars, *arg_specs)\u001b[0m\n\u001b[1;32m    770\u001b[0m       device_assignment=(device.id,) if device else None)\n\u001b[1;32m    771\u001b[0m   \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameter_is_tupled_arguments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtuple_args\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 772\u001b[0;31m   \u001b[0mcompiled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompile_or_get_cached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuilt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    773\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mnreps\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    774\u001b[0m     return partial(_execute_compiled, compiled, out_avals, result_handlers,\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36mcompile_or_get_cached\u001b[0;34m(backend, computation, compile_options)\u001b[0m\n\u001b[1;32m     79\u001b[0m             \u001b[0mcc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mput_executable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomputation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mbackend_compile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomputation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     82\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0midentity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36mbackend_compile\u001b[0;34m(backend, built_c, options)\u001b[0m\n\u001b[1;32m    383\u001b[0m   \u001b[0;31m# we use a separate function call to ensure that XLA compilation appears\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    384\u001b[0m   \u001b[0;31m# separately in Python profiling results\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 385\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilt_c\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    386\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    387\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_execute_compiled_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult_handler\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "iQ1eX-9m9PtW"
+      },
+      "source": [
+        "#np.save(Folder+'/Images/history_trust-constr_hess.npy',history)\n",
+        "history_trust_constr_hess=np.load(Folder+'/Images/history_trust-constr_hess.npy',allow_pickle=True)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "fgWVwwqiOUL6"
+      },
+      "source": [
+        "history=history_trust_constr_hess"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "UXcywbx_tU6C"
+      },
+      "source": [
+        "loss_history=np.array([loss_func(x) for x in history])\n",
+        "grads_history=np.array([grad_loss_func(x) for x in history])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 597
+        },
+        "id": "v9AQdBMatW6l",
+        "outputId": "38f34d55-6e86-41aa-dfee-501a956b44f9"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
+        "\n",
+        "ax[0].plot(history[:,0],label='Fitting')\n",
+        "ax[0].set_title('Log(Amp)')\n",
+        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
+        "#ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
+        "#ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
+        "ax[0].legend()\n",
+        "\n",
+        "\n",
+        "\n",
+        "grads_history=np.array(grads_history)\n",
+        "loss_history=np.array(loss_history)\n",
+        "\n",
+        "ax[1].plot(np.abs(grads_history[:,0]))\n",
+        "ax[1].set_yscale('log')\n",
+        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
+        "\n",
+        "\n",
+        "ax[2].plot(history[:,1],label='Fitting')\n",
+        "ax[2].set_title('Beta')\n",
+        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
+        "ax[2].legend()\n",
+        "\n",
+        "ax[3].plot(np.abs(grads_history[:,1]))\n",
+        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
+        "ax[3].set_yscale('log')\n",
+        "\n",
+        "\n",
+        "\n",
+        "ax[4].plot(loss_history)\n",
+        "ax[4].set_yscale('log')\n",
+        "ax[4].set_title('Loss')\n",
+        "\n",
+        "fig.tight_layout()\n",
+        "fig.suptitle('weighted MAE loss',y=1.1)\n",
+        "\n",
+        "\n",
+        "\n",
+        "fig.add_subplot(111, frameon=False)\n",
+        "# hide tick and tick label of the big axis\n",
+        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
+        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1440x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "evdwjjYsF2Mp"
+      },
+      "source": [
+        "### only jac"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ssQE2yZXtXFb",
+        "outputId": "9a809710-2b85-47a1-8420-c080171e24aa"
+      },
+      "source": [
+        "Nfeval = 1\n",
+        "history=np.zeros((0,2))\n",
+        "init_guess=np.array([0.,GRF_beta])\n",
+        "bounds=((-10., -0.), (1., 6.0))\n",
+        "\n",
+        "def callbackF(Xi,optimizer):\n",
+        "    global Nfeval\n",
+        "    global history\n",
+        "    loss=loss_func(Xi)\n",
+        "    grad=grad_loss_func(Xi)\n",
+        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
+        "    Nfeval += 1\n",
+        "    history=np.append(history,[Xi],axis=0)\n",
+        "\n",
+        "\n",
+        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "   1   -0.035741    4.949092    207.091483    0.137991 -2.910105\n",
+            "   2   -0.424350    5.356864    207.314332    0.008007  0.407781\n",
+            "   3   -0.431992    5.313520    207.311712    0.003525  0.012143\n",
+            "   4   -0.431992    5.313520    207.311712    0.003525  0.012143\n",
+            "   5   -0.431992    5.313520    207.311712    0.003525  0.012143\n",
+            "   6   -0.436854    5.311473    207.311669    0.003739  0.012419\n",
+            "   7   -0.441763    5.309396    207.311624    0.003970  0.012851\n",
+            "   8   -0.446726    5.307272    207.311575    0.004221  0.013452\n",
+            "   9   -0.451755    5.305082    207.311523    0.004496  0.014247\n",
+            "  10   -0.456862    5.302805    207.311466    0.004799  0.015270\n",
+            "  11   -0.462061    5.300414    207.311402    0.005137  0.016572\n",
+            "  12   -0.467368    5.297880    207.311330    0.005519  0.018223\n",
+            "  13   -0.472807    5.295164    207.311246    0.005959  0.020327\n",
+            "  14   -0.478405    5.292215    207.311148    0.006473  0.023023\n",
+            "  15   -0.484199    5.288968    207.311028    0.007088  0.026501\n",
+            "  16   -0.490237    5.285335    207.310879    0.007842  0.030990\n",
+            "  17   -0.491335    5.281023    207.310726    0.008587  0.035966\n",
+            "  18   -0.492462    5.276185    207.310528    0.009519  0.041437\n",
+            "  19   -0.493634    5.270758    207.310278    0.010648  0.045645\n",
+            "  20   -0.494870    5.264862    207.309995    0.011870  0.044719\n",
+            "  21   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
+            "  22   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
+            "  23   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
+            "  24   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
+            "  25   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
+            "  26   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
+            "  27   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
+            "  28   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
+            "  29   -0.631694    3.944712    206.771223    1.747185  8.995471\n",
+            "  30   -0.631694    3.944712    206.771223    1.747185  8.995471\n",
+            "  31   -0.631694    3.944712    206.771223    1.747185  8.995471\n",
+            "  32   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
+            "  33   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
+            "  34   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
+            "  35   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
+            "  36   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
+            "  37   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
+            "  38   -0.634361    3.918717    205.797457    3.815107  19.592749\n",
+            "  39   -0.643190    3.914915    205.796233    4.214211 -36.744026\n",
+            "  40   -0.652298    3.917299    205.711318    4.193017 -0.091102\n",
+            "  41   -0.717507    3.920806    205.570851    3.730697  67.073334\n",
+            "  42   -0.856677    3.916114    204.615300    6.382287  37.682571\n",
+            "  43   -1.943516    3.907607    198.627578    0.925284  88.272267\n",
+            "  44   -2.354892    3.897963    192.153963    22.140011  40.565561\n",
+            "  45   -7.294712    3.843118    0.449401   -1.252996 -0.320715\n",
+            "  46   -7.294712    3.843118    0.449401   -1.252996 -0.320715\n",
+            "  47   -7.294712    3.843118    0.449401   -1.252996 -0.320715\n",
+            "  48   -7.152337    3.841766    0.366107    0.484929  0.296541\n",
+            "  49   -7.214154    3.841547    0.356168   -0.555669 -0.063573\n",
+            "  50   -7.181117    3.841647    0.355137    0.255803  0.211960\n",
+            "  51   -7.191502    3.841599    0.352837    0.147883  0.174043\n",
+            "  52   -7.205689    3.841518    0.352314   -0.361640  0.002803\n",
+            "  53   -7.195610    3.841559    0.352226    0.146139  0.172325\n",
+            "  54   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
+            "  55   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
+            "  56   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
+            "  57   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
+            "  58   -7.203140    3.841462    0.351680   -0.159856  0.067183\n",
+            "  59   -7.203140    3.841462    0.351680   -0.159856  0.067183\n",
+            "  60   -7.200889    3.841466    0.351603    0.043097  0.136283\n",
+            "  61   -7.201768    3.841435    0.351592   -0.058797  0.103612\n",
+            "  62   -7.201285    3.841434    0.351581    0.043017  0.136150\n",
+            "  63   -7.201478    3.841416    0.351573   -0.058821  0.103685\n",
+            "  64   -7.201478    3.841416    0.351573   -0.058821  0.103685\n",
+            "  65   -7.201389    3.841366    0.351568    0.042976  0.136110\n",
+            "  66   -7.201620    3.840723    0.351509   -0.058987  0.103621\n",
+            "  67   -7.200847    3.839571    0.351346    0.042480  0.136135\n",
+            "  68   -7.197730    3.830531    0.350243    0.040034  0.136396\n",
+            "  69   -7.190141    3.810756    0.347821    0.034713  0.137272\n",
+            "  70   -7.182349    3.790505    0.345298    0.130343  0.170992\n",
+            "  71   -7.129484    3.648099    0.326441    0.189485  0.205147\n",
+            "  72   -7.129484    3.648099    0.326441    0.189485  0.205147\n",
+            "  73   -7.129484    3.648099    0.326441    0.189485  0.205147\n",
+            "  74   -7.142139    3.595737    0.324840   -0.829791 -0.077609\n",
+            "  75   -7.104735    3.598753    0.320712    0.176230  0.210812\n",
+            "  76   -7.100287    3.545210    0.310274    0.150602  0.206386\n",
+            "  77   -7.080791    3.169565    0.295208   -1.635611 -0.083293\n",
+            "  78   -6.990308    2.805311    0.173775   -0.326566  0.159380\n",
+            "  79   -6.990308    2.805311    0.173775   -0.326566  0.159380\n",
+            "  80   -6.978760    2.740722    0.159559   -0.252105  0.177217\n",
+            "  81   -6.968345    2.675363    0.146447   -0.084837  0.192216\n",
+            "  82   -6.903430    2.220487    0.140182    2.036467 -0.166330\n",
+            "  83   -6.951547    2.515899    0.117652    0.329173  0.202077\n",
+            "  84   -6.945788    2.427485    0.104338    0.766408  0.173795\n",
+            "  85   -6.943547    2.118610    0.080038    2.253988 -0.345901\n",
+            "  86   -6.955498    2.300492    0.075668    0.709605  0.165560\n",
+            "  87   -6.964633    2.232445    0.058226    0.674310  0.161521\n",
+            "  88   -6.964633    2.232445    0.058226    0.674310  0.161521\n",
+            "  89   -7.030850    1.886201    0.035184   -0.951630 -0.037996\n",
+            "  90   -7.030850    1.886201    0.035184   -0.951630 -0.037996\n",
+            "  91   -6.995145    2.055367    0.013964   -1.040364  0.334968\n",
+            "  92   -6.995145    2.055367    0.013964   -1.040364  0.334968\n",
+            "  93   -6.995145    2.055367    0.013964   -1.040364  0.334968\n",
+            "  94   -6.999754    1.985130    0.007279    2.267917 -0.457693\n",
+            "  95   -6.999754    1.985130    0.007279    2.267917 -0.457693\n",
+            "  96   -7.005029    1.985710    0.006027   -1.280828  0.031835\n",
+            "  97   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
+            "  98   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
+            "  99   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
+            " 100   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
+            " 101   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
+            " 102   -7.001737    1.985818    0.003391    0.244545 -0.269760\n",
+            " 103   -7.001976    1.986361    0.003262   -0.258870 -0.201538\n",
+            " 104   -7.001597    1.987470    0.002980    0.137035 -0.255777\n",
+            " 105   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
+            " 106   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
+            " 107   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
+            " 108   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
+            " 109   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
+            " 110   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
+            " 111   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
+            " 112   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
+            " 113   -6.999925    2.001528    0.000513   -2.246569  0.445733\n",
+            " 114   -6.999925    2.001528    0.000513   -2.246569  0.445733\n",
+            " 115   -6.999719    2.001506    0.000389    0.652224  0.137145\n",
+            " 116   -6.999719    2.001506    0.000389    0.652224  0.137145\n",
+            " 117   -6.999772    2.001453    0.000353    0.352092  0.187890\n",
+            " 118   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
+            " 119   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
+            " 120   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
+            " 121   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
+            " 122   -6.999872    2.000989    0.000235   -0.029692  0.241174\n",
+            " 123   -6.999861    2.000942    0.000226    0.265198  0.200894\n",
+            " 124   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
+            " 125   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
+            " 126   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
+            " 127   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
+            " 128   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
+            " 129   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
+            " 130   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
+            " 131   -6.999916    2.000604    0.000144    0.174463  0.213762\n",
+            " 132   -6.999916    2.000604    0.000144    0.174463  0.213762\n",
+            " 133   -6.999925    2.000596    0.000142   -0.237093  0.267345\n",
+            " 134   -6.999923    2.000524    0.000126    0.265013  0.200912\n",
+            " 135   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 136   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 137   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 138   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 139   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 140   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 141   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 142   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 143   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 144   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 145   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
+            " 146   -6.999997    2.000017    0.000005    0.651523  0.137089\n",
+            " 147   -6.999997    2.000017    0.000005    0.651523  0.137089\n",
+            " 148   -6.999997    2.000017    0.000004    0.351460  0.187931\n",
+            " 149   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
+            " 150   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
+            " 151   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
+            " 152   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
+            " 153   -6.999999    2.000012    0.000003   -0.030162  0.241285\n",
+            " 154   -6.999998    2.000011    0.000003    0.264787  0.200935\n",
+            " 155   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
+            " 156   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
+            " 157   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
+            " 158   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
+            " 159   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
+            " 160   -6.999999    2.000007    0.000002    0.264786  0.200935\n",
+            " 161   -6.999999    2.000007    0.000002   -0.642877  0.313361\n",
+            " 162   -6.999999    2.000006    0.000001    0.174194  0.213800\n",
+            " 163   -7.000000    2.000004    0.000001   -0.237392  0.267441\n",
+            " 164   -7.000000    2.000004    0.000001   -0.237392  0.267441\n",
+            " 165   -7.000000    2.000004    0.000001   -0.237392  0.267441\n",
+            " 166   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
+            " 167   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
+            " 168   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
+            " 169   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
+            " 170   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
+            " 171   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
+            " 172   -7.000000    1.999999    0.000000   -0.351452 -0.187932\n",
+            " 173   -7.000000    1.999999    0.000000   -0.351452 -0.187932\n",
+            " 174   -7.000000    1.999999    0.000000   -0.174191 -0.213801\n",
+            " 175   -7.000000    1.999999    0.000000   -0.079316 -0.226824\n",
+            " 176   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
+            " 177   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
+            " 178   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
+            " 179   -7.000000    2.000001    0.000000   -0.337255  0.279357\n",
+            " 180   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
+            " 181   -7.000000    2.000000    0.000000    0.174192  0.213801\n",
+            " 182   -7.000000    2.000000    0.000000   -2.248032  0.446728\n",
+            " 183   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 184   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 185   -7.000000    2.000000    0.000000   -0.834370 -0.093982\n",
+            " 186   -7.000000    2.000000    0.000000   -0.834370 -0.093982\n",
+            " 187   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 188   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 189   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 190   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 191   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 192   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
+            " 193   -7.000000    2.000000    0.000000   -2.248032  0.446728\n",
+            " 194   -7.000000    2.000000    0.000000    1.293971 -0.030625\n",
+            " 195   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 196   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 197   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 198   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 199   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 200   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 201   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 202   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 203   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 204   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 205   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 206   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 207   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 208   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 209   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 210   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 211   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 212   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 213   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 214   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 215   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 216   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 217   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 218   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 219   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 220   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 221   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 222   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 223   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 224   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 225   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 226   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 227   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 228   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 229   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 230   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 231   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 232   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 233   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 234   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 235   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 236   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 237   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 238   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 239   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 240   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 241   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 242   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 243   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 244   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 245   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 246   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 247   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 248   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 249   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 250   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 251   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 252   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 253   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 254   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 255   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 256   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 257   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 258   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 259   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 260   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 261   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 262   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 263   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 264   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 265   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 266   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 267   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 268   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 269   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 270   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 271   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 272   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 273   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 274   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 275   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 276   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 277   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 278   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 279   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 280   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 281   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 282   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 283   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 284   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 285   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 286   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 287   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 288   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 289   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 290   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 291   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 292   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 293   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 294   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 295   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 296   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 297   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 298   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 299   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 300   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 301   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 302   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 303   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 304   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 305   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 306   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 307   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 308   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 309   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 310   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 311   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 312   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 313   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 314   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 315   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 316   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 317   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 318   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 319   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 320   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 321   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            " 322   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
+            "`xtol` termination condition is satisfied.\n",
+            "Number of iterations: 322, function evaluations: 416, CG iterations: 457, optimality: 5.76e-01, constraint violation: 0.00e+00, execution time: 4.2e+01 s.\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "pBcPJ6lLtXQd"
+      },
+      "source": [
+        "#np.save(Folder+'/Images/history_trust-constr_jac_tight_bounds.npy',history)\n",
+        "\n",
+        "#Bounds ((-10.,0.),(1.,10.))\n",
+        "history_trust_constr_jac_loose_bounds=np.load(Folder+'/Images/history_trust-constr_jac_loose_bounds.npy',allow_pickle=True)\n",
+        "\n",
+        "#Bounds ((-10.,0.),(1.,6.))\n",
+        "history_trust_constr_jac_tight_bounds=np.load(Folder+'/Images/history_trust-constr_jac_tight_bounds.npy',allow_pickle=True)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "R1NH-OqwKx6j"
+      },
+      "source": [
+        "history=history_trust_constr_jac_loose_bounds"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bNJsnrjyGHFg"
+      },
+      "source": [
+        "loss_history=np.array([loss_func(x) for x in history])\n",
+        "grads_history=np.array([grad_loss_func(x) for x in history])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 597
+        },
+        "id": "C-hkCokuGHO1",
+        "outputId": "30921ea8-d3a4-4a1e-8f5c-b05c47c1874d"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
+        "\n",
+        "ax[0].plot(history[:,0],label='Fitting')\n",
+        "ax[0].set_title('Log(Amp)')\n",
+        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
+        "ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
+        "ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
+        "ax[0].legend()\n",
+        "\n",
+        "\n",
+        "\n",
+        "grads_history=np.array(grads_history)\n",
+        "loss_history=np.array(loss_history)\n",
+        "\n",
+        "ax[1].plot(np.abs(grads_history[:,0]))\n",
+        "ax[1].set_yscale('log')\n",
+        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
+        "\n",
+        "\n",
+        "ax[2].plot(history[:,1],label='Fitting')\n",
+        "ax[2].set_title('Beta')\n",
+        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
+        "ax[2].legend()\n",
+        "\n",
+        "ax[3].plot(np.abs(grads_history[:,1]))\n",
+        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
+        "ax[3].set_yscale('log')\n",
+        "\n",
+        "\n",
+        "\n",
+        "ax[4].plot(loss_history)\n",
+        "ax[4].set_yscale('log')\n",
+        "ax[4].set_title('Loss')\n",
+        "\n",
+        "fig.tight_layout()\n",
+        "fig.suptitle('weighted MAE loss',y=1.1)\n",
+        "\n",
+        "\n",
+        "\n",
+        "fig.add_subplot(111, frameon=False)\n",
+        "# hide tick and tick label of the big axis\n",
+        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
+        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1440x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wQJOF7jjU-rS"
+      },
+      "source": [
+        "## MSE loss function"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "S2eydSBcGQ_s"
+      },
+      "source": [
+        "#Pick spectrum loss type (weighted MSE or weighted MAE)\n",
+        "Spectra_Loss_pure=purify_function(Spectra_Loss_MSE,resid_true_spectrum)\n",
+        "GRF_Loss_args=(GRF_seed,unperturbed_image,get_jaxified_GRF_pure,simulate_perturbed_image_pure,compute_radial_spectrum_pure,Spectra_Loss_pure)\n",
+        "\n",
+        "#Precompile GRF_Loss \n",
+        "GRF_Loss_pure=purify_function(GRF_Loss,*GRF_Loss_args)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "C8o2ZWBdGHa9"
+      },
+      "source": [
+        "loss_func=GRF_Loss_pure\n",
+        "grad_loss_func=jax.grad(GRF_Loss_pure)\n",
+        "hess_loss_func=jax.jacfwd(jax.jacrev(loss_func))"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 332
+        },
+        "id": "peWh2ReHVGq5",
+        "outputId": "f541fd69-a7e5-4ac3-f260-e2214e2a4d79"
+      },
+      "source": [
+        "print('Loss: Guess={:.2f}, True:{:.2f}'.format(loss_func(GRF_init_guess),loss_func([GRF_LogAmp,GRF_beta])))\n",
+        "grad_loss=grad_loss_func(GRF_init_guess)\n",
+        "print('Grad Loss in guess: grad(logA)={:.2f}, grad(Beta)={:.2f}'.format(grad_loss[0],grad_loss[1]))\n",
+        "\n",
+        "hess_loss=hess_loss_func(GRF_init_guess)\n",
+        "sns.heatmap(np.log10(np.abs(hess_loss)),xticklabels=['logA','Beta'],yticklabels=['logA','Beta'],annot=True,fmt='.2f')\n",
+        "plt.title('Log(Abs(Hessian))')"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Loss: Guess=93898.53, True:0.00\n",
+            "Grad Loss in guess: grad(logA)=124.37, grad(Beta)=-2654.02\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Text(0.5, 1.0, 'Log(Abs(Hessian))')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 215
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lF3UWo-yVMwG"
+      },
+      "source": [
+        "## Loss function and grads"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fY6qJidiVJMm",
+        "outputId": "74af27f1-3c9a-491a-c546-f42ceca96c72"
+      },
+      "source": [
+        "GRF_Amps_array=np.linspace(-7.05,-6.95,100)\n",
+        "GRF_Betas_array=np.linspace(1.5,2.5,100)\n",
+        "\n",
+        "GRF_losses_grid=np.zeros((100,100))\n",
+        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
+        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
+        "\n",
+        "for i in tqdm(range(100)):\n",
+        "  for j in range(100):\n",
+        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
+        "    GRF_Betas_grad_grid[i,j]=grad[1]"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 100/100 [08:24<00:00,  5.05s/it]\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 513
+        },
+        "id": "BQp3MRo5VQTK",
+        "outputId": "e7c8c447-1368-4e66-8ec0-ce7f787e4a07"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
+        "\n",
+        "y_labels=np.round(GRF_Amps_array,9)\n",
+        "x_labels=np.round(GRF_Betas_array,2)\n",
+        "\n",
+        "num_ticks = 10\n",
+        "# the index of the position of yticks\n",
+        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
+        "# the content of labels of these yticks\n",
+        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
+        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
+        "\n",
+        "\n",
+        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "ax[1].set_yticks([])\n",
+        "ax[2].set_yticks([])\n",
+        "\n",
+        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
+        "for i in range(3):\n",
+        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
+        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
+        "  ax[i].invert_yaxis()\n",
+        "\n",
+        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
+        "fig.tight_layout()\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ZXMjTiXoVT0O",
+        "outputId": "ac8df346-a4e3-4496-e297-10c1ff5aea7a"
+      },
+      "source": [
+        "GRF_Amps_array=np.linspace(-10.,-6.,100)\n",
+        "GRF_Betas_array=np.linspace(1.,8.,100)\n",
+        "\n",
+        "GRF_losses_grid=np.zeros((100,100))\n",
+        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
+        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
+        "\n",
+        "for i in tqdm(range(100)):\n",
+        "  for j in range(100):\n",
+        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
+        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
+        "    GRF_Betas_grad_grid[i,j]=grad[1]"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 100/100 [08:23<00:00,  5.04s/it]\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "XGh262Uwb9gu"
+      },
+      "source": [
+        "history_hess_x_labels,history_hess_y_labels=reindex_history(np.load(Folder+'/Images/MSEhistory_trust-constr_hess.npy',allow_pickle=True))\n",
+        "history_jac_loose_x_labels,history_jac_loose_y_labels=reindex_history(np.load(Folder+'/Images/MSEhistory_trust-constr_jac_loose_bounds.npy',allow_pickle=True))\n",
+        "history_jac_tight_x_labels,history_jac_tight_y_labels=reindex_history(np.load(Folder+'/Images/MSEhistory_trust-constr_jac_tight_bounds.npy',allow_pickle=True))"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 513
+        },
+        "id": "kRSmFm1uVX3j",
+        "outputId": "828b7a2e-b21b-4769-f21b-e35621a5212b"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
+        "\n",
+        "y_labels=np.round(GRF_Amps_array,9)\n",
+        "x_labels=np.round(GRF_Betas_array,2)\n",
+        "\n",
+        "num_ticks = 10\n",
+        "# the index of the position of yticks\n",
+        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
+        "# the content of labels of these yticks\n",
+        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
+        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
+        "\n",
+        "#Loss\n",
+        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "#Fitting\n",
+        "#sns.lineplot(ax=ax[0],x=history_hess_x_labels,y=history_hess_y_labels,label='Hessian fitting',color='C0')\n",
+        "#ax[0].lines[0].set_linestyle((0, (1, 4)))\n",
+        "#sns.lineplot(ax=ax[0],x=history_jac_loose_x_labels,y=history_jac_loose_y_labels,label='Jac loose bounds fitting',color='black')\n",
+        "#ax[0].lines[1].set_linestyle((0, (3, 5, 1, 5)))\n",
+        "#sns.lineplot(ax=ax[0],x=history_jac_tight_x_labels,y=history_jac_tight_y_labels,label='Jac tight bounds fitting',color='C2')\n",
+        "#ax[0].lines[2].set_linestyle((0, (5, 5)))\n",
+        "#ax[0].legend(loc='lower left')\n",
+        "\n",
+        "#Grad Amp\n",
+        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "#Grad Beta\n",
+        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "ax[1].set_yticks([])\n",
+        "ax[2].set_yticks([])\n",
+        "\n",
+        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
+        "for i in range(3):\n",
+        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
+        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
+        "  ax[i].invert_yaxis()\n",
+        "  \n",
+        "\n",
+        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
+        "fig.tight_layout()\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "GncKODsRg777"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kDgxu80Mkvgu"
+      },
+      "source": [
+        "### Possible correlation with physical characteristics of the GRF\n",
+        "\n",
+        "$A \\propto \\frac{\\sigma^2_{\\delta \\psi}}{\\sum_{k_x} \\sum_{k_y} k^{-\\beta}} \\propto \\frac{\\sigma^2_{\\delta \\alpha}}{\\sum_{k_x} \\sum_{k_y} k^{-\\beta+2}} \\propto \\frac{\\sigma^2_{\\delta \\kappa}}{\\sum_{k_x} \\sum_{k_y} k^{-\\beta+4}}$"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "rCw1_TWNeaq4"
+      },
+      "source": [
+        "k_grid,_=PowerBox_jax.get_k_grid_dx(npix,pix_scl)\n",
+        "k_grid[50,50]=np.inf"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DUajk0GzfDFi",
+        "outputId": "9078fc2b-d1ff-4f40-d3fc-27fe5d028060"
+      },
+      "source": [
+        "variance_stat_sum=np.zeros(100)\n",
+        "deflection_stat_sum=np.zeros(100)\n",
+        "convergence_stat_sum=np.zeros(100)\n",
+        "\n",
+        "for i in tqdm(range(100)):\n",
+        "    variance_stat_sum[i]=np.power(k_grid,-GRF_Betas_array[i]).sum()\n",
+        "    deflection_stat_sum[i]=np.power(k_grid,-GRF_Betas_array[i]+2).sum()\n",
+        "    convergence_stat_sum[i]=np.power(k_grid,-GRF_Betas_array[i]+4).sum()\n",
+        "\n",
+        "deflection_stat_sum[deflection_stat_sum==np.inf]=np.nan\n",
+        "convergence_stat_sum[convergence_stat_sum==np.inf]=np.nan\n",
+        "\n",
+        "Variance_image=np.outer(np.power(10,GRF_Amps_array),variance_stat_sum)\n",
+        "Deflection_image=np.outer(np.power(10,GRF_Amps_array),deflection_stat_sum)\n",
+        "Convergence_image=np.outer(np.power(10,GRF_Amps_array),convergence_stat_sum)\n",
+        "\n",
+        "const_Var=np.log10((1e-10*variance_stat_sum[-1])/variance_stat_sum)\n",
+        "const_Def=np.log10((1e-10*deflection_stat_sum[-1])/deflection_stat_sum)\n",
+        "const_Conv=np.log10((1e-10*convergence_stat_sum[-1])/convergence_stat_sum)\n",
+        "\n",
+        "\n",
+        "const_x_Beta,const_Var_Amp=reindex_history(np.vstack((const_Var,GRF_Betas_array)).T)\n",
+        "const_x_Beta,const_Def_Amp=reindex_history(np.vstack((const_Def,GRF_Betas_array)).T)\n",
+        "const_x_Beta,const_Conv_Amp=reindex_history(np.vstack((const_Conv,GRF_Betas_array)).T)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 100/100 [00:00<00:00, 506.53it/s]\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 575
+        },
+        "id": "OVmUg_Kuo-hV",
+        "outputId": "d36cb8fc-4884-4635-b7ae-7b42d14f862f"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
+        "\n",
+        "y_labels=np.round(GRF_Amps_array,9)\n",
+        "x_labels=np.round(GRF_Betas_array,2)\n",
+        "\n",
+        "num_ticks = 10\n",
+        "# the index of the position of yticks\n",
+        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
+        "# the content of labels of these yticks\n",
+        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
+        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
+        "\n",
+        "#Loss\n",
+        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "\n",
+        "#Grad Amp\n",
+        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "#Grad Beta\n",
+        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "ax[1].set_yticks([])\n",
+        "ax[2].set_yticks([])\n",
+        "\n",
+        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
+        "for i in range(3):\n",
+        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
+        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
+        "  ax[i].invert_yaxis()\n",
+        "\n",
+        "  #Const levels\n",
+        "  sns.lineplot(ax=ax[i],x=const_x_Beta,y=const_Var_Amp,label=r'$\\sigma^2_{\\psi}=const$',color='C0')\n",
+        "  ax[i].lines[0].set_linestyle('solid')\n",
+        "  sns.lineplot(ax=ax[i],x=const_x_Beta,y=const_Def_Amp,label=r'$\\sigma^2_{\\alpha}=const$',color='black')\n",
+        "  ax[i].lines[1].set_linestyle('solid')\n",
+        "  sns.lineplot(ax=ax[i],x=const_x_Beta,y=const_Conv_Amp,label=r'$\\sigma^2_{\\kappa}=const$',color='C2')\n",
+        "  ax[i].lines[2].set_linestyle('solid')\n",
+        "  ax[i].legend(loc='lower left')\n",
+        "  \n",
+        " \n",
+        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
+        "fig.tight_layout()\n",
+        "fig.suptitle('Relation to physical characteristics of the GRF',y=1.1)\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 513
+        },
+        "id": "hmgyJrVpg9AZ",
+        "outputId": "002997bf-7a6c-494d-c540-756179a2c0f2"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,4,figsize=(15,7))\n",
+        "\n",
+        "y_labels=np.round(GRF_Amps_array,9)\n",
+        "x_labels=np.round(GRF_Betas_array,2)\n",
+        "\n",
+        "num_ticks = 10\n",
+        "# the index of the position of yticks\n",
+        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
+        "# the content of labels of these yticks\n",
+        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
+        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "#Loss\n",
+        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "#Const levels\n",
+        "sns.lineplot(ax=ax[0],x=const_x_Beta,y=const_Var_Amp,label=r'$\\sigma^2_{\\delta \\psi}=const$',color='C0')\n",
+        "ax[0].lines[0].set_linestyle((0, (1, 4)))\n",
+        "sns.lineplot(ax=ax[0],x=const_x_Beta,y=const_Def_Amp,label=r'$\\sigma^2_{\\delta \\alpha}=const$',color='black')\n",
+        "ax[0].lines[1].set_linestyle((0, (3, 5, 1, 5)))\n",
+        "sns.lineplot(ax=ax[0],x=const_x_Beta,y=const_Conv_Amp,label=r'$\\sigma^2_{\\delta \\kappa}=const$',color='C2')\n",
+        "ax[0].lines[2].set_linestyle((0, (5, 5)))\n",
+        "ax[0].legend(loc='lower left')\n",
+        "\n",
+        "#Variance\n",
+        "im=sns.heatmap(ax=ax[1],data=np.log10(Variance_image),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "#Deflection\n",
+        "im=sns.heatmap(ax=ax[2],data=np.log10(Deflection_image),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "#Convergence\n",
+        "im=sns.heatmap(ax=ax[3],data=np.log10(Convergence_image),xticklabels=xticklabels,yticklabels=yticklabels)\n",
+        "im.set_yticks(ticks)\n",
+        "im.set_xticks(ticks)\n",
+        "\n",
+        "ax[1].set_yticks([])\n",
+        "ax[2].set_yticks([])\n",
+        "ax[3].set_yticks([])\n",
+        "\n",
+        "fig_names=[r'$log(Loss)$','log(Variance)','log(Deflection)','log(Convergence)']\n",
+        "for i in range(4):\n",
+        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
+        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
+        "  ax[i].invert_yaxis()\n",
+        "  \n",
+        "\n",
+        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
+        "fig.tight_layout()\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x504 with 8 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "gmUHJzlmmQs3"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "iRI75po1mQ2R"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "det903ojmQ78"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pOpk6BLaVgvD"
+      },
+      "source": [
+        "## Optimize"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sBnEeyMeVh-r"
+      },
+      "source": [
+        "### with hessian"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "E_P2jxmIVc81",
+        "outputId": "160fb165-0e5a-441f-e133-bb38c87305d0"
+      },
+      "source": [
+        "Nfeval = 1\n",
+        "history=np.zeros((0,2))\n",
+        "init_guess=np.array([-1.,GRF_beta])\n",
+        "bounds=((-10., -0.), (1., 10.0))\n",
+        "\n",
+        "def callbackF(Xi,optimizer):\n",
+        "    global Nfeval\n",
+        "    global history\n",
+        "    loss=loss_func(Xi)\n",
+        "    grad=grad_loss_func(Xi)\n",
+        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
+        "    Nfeval += 1\n",
+        "    history=np.append(history,[Xi],axis=0)\n",
+        "\n",
+        "\n",
+        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,hess=hess_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "   1   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
+            "   2   -0.856200    4.945830    93802.966953    169.763134 -565.016849\n",
+            "   3   -5.868603    4.823393    2060.714368    10809.194234  5231.891315\n",
+            "   4   -5.963693    4.624140    765.942570    3926.522233  1850.125030\n",
+            "   5   -6.118314    4.552678    295.923386    1480.874943  693.268645\n",
+            "   6   -6.296659    4.512743    109.559732    556.830098  256.625525\n",
+            "   7   -6.493893    4.507251    39.090181    205.817236  94.455083\n",
+            "   8   -6.688996    4.499141    13.265328    74.782952  34.160232\n",
+            "   9   -6.846187    4.427419    4.337609    26.852622  12.029882\n",
+            "  10   -6.993091    4.361358    1.378231    9.337655  4.160843\n",
+            "  11   -7.121073    4.303814    0.494322    3.024544  1.398408\n",
+            "  12   -7.217084    4.258816    0.282365    0.821834  0.455768\n",
+            "  13   -7.268478    4.229778    0.250500    0.127337  0.163385\n",
+            "  14   -7.268478    4.229778    0.250500    0.127337  0.163385\n",
+            "  15   -7.268478    4.229778    0.250500    0.127337  0.163385\n",
+            "  16   -7.111189    3.796283    0.193141    0.077647  0.176693\n",
+            "  17   -7.111189    3.796283    0.193141    0.077647  0.176693\n",
+            "  18   -7.040381    3.484822    0.142384   -0.086890  0.152354\n",
+            "  19   -7.040381    3.484822    0.142384   -0.086890  0.152354\n",
+            "  20   -6.946291    3.284432    0.116975    0.561945  0.219962\n",
+            "  21   -6.955260    3.052993    0.076798    0.078366  0.123218\n",
+            "  22   -6.955260    3.052993    0.076798    0.078366  0.123218\n",
+            "  23   -6.955260    3.052993    0.076798    0.078366  0.123218\n",
+            "  24   -6.869221    2.260935    0.057663    1.264530 -0.108432\n",
+            "  25   -6.936373    2.265359    0.009101    0.253859  0.016325\n",
+            "  26   -6.957793    2.265176    0.006204    0.022189  0.042833\n",
+            "  27   -6.957793    2.265176    0.006204    0.022189  0.042833\n",
+            "  28   -6.987207    2.023089    0.000427    0.089673 -0.012133\n",
+            "  29   -6.995235    2.023894    0.000053    0.003518  0.003727\n",
+            "  30   -6.995235    2.023894    0.000053    0.003518  0.003727\n",
+            "  31   -6.999156    2.004130    0.000002    0.000702  0.000626\n",
+            "  32   -6.999156    2.004130    0.000002    0.000702  0.000626\n",
+            "  33   -6.999845    2.000799    0.000000    0.000046  0.000138\n",
+            "  34   -6.999845    2.000799    0.000000    0.000046  0.000138\n",
+            "  35   -6.999969    2.000159    0.000000    0.000007  0.000028\n",
+            "  36   -6.999969    2.000159    0.000000    0.000007  0.000028\n",
+            "  37   -6.999994    2.000032    0.000000    0.000001  0.000006\n",
+            "  38   -6.999994    2.000032    0.000000    0.000001  0.000006\n",
+            "  39   -6.999999    2.000006    0.000000    0.000000  0.000001\n",
+            "`gtol` termination condition is satisfied.\n",
+            "Number of iterations: 39, function evaluations: 31, CG iterations: 53, optimality: 7.98e-10, constraint violation: 0.00e+00, execution time: 4.5e+02 s.\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Nc2uJx_1VkGV"
+      },
+      "source": [
+        "np.save(Folder+'/Images/MSEhistory_trust-constr_hess.npy',history)\n",
+        "history_trust_constr_hess=np.load(Folder+'/Images/MSEhistory_trust-constr_hess.npy',allow_pickle=True)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Nq9ySFDpVtNY"
+      },
+      "source": [
+        "loss_history=np.array([loss_func(x) for x in history])\n",
+        "grads_history=np.array([grad_loss_func(x) for x in history])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 597
+        },
+        "id": "Bi0GwbjHVwND",
+        "outputId": "1192a74c-fd5f-4cc1-c860-1ee51b784927"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
+        "\n",
+        "ax[0].plot(history[:,0],label='Fitting')\n",
+        "ax[0].set_title('Log(Amp)')\n",
+        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
+        "#ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
+        "#ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
+        "ax[0].legend()\n",
+        "\n",
+        "\n",
+        "\n",
+        "grads_history=np.array(grads_history)\n",
+        "loss_history=np.array(loss_history)\n",
+        "\n",
+        "ax[1].plot(np.abs(grads_history[:,0]))\n",
+        "ax[1].set_yscale('log')\n",
+        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
+        "\n",
+        "\n",
+        "ax[2].plot(history[:,1],label='Fitting')\n",
+        "ax[2].set_title('Beta')\n",
+        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
+        "ax[2].legend()\n",
+        "\n",
+        "ax[3].plot(np.abs(grads_history[:,1]))\n",
+        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
+        "ax[3].set_yscale('log')\n",
+        "\n",
+        "\n",
+        "\n",
+        "ax[4].plot(loss_history)\n",
+        "ax[4].set_yscale('log')\n",
+        "ax[4].set_title('Loss')\n",
+        "\n",
+        "fig.tight_layout()\n",
+        "fig.suptitle('weighted MAE loss',y=1.1)\n",
+        "\n",
+        "\n",
+        "\n",
+        "fig.add_subplot(111, frameon=False)\n",
+        "# hide tick and tick label of the big axis\n",
+        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
+        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1440x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Lg18vRuvV1O1"
+      },
+      "source": [
+        "### only jacobian"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NGYAzPx0VyYr",
+        "outputId": "8a736af9-8a14-4a97-a390-d4150eff871a"
+      },
+      "source": [
+        "Nfeval = 1\n",
+        "history=np.zeros((0,2))\n",
+        "init_guess=np.array([0.,GRF_beta])\n",
+        "bounds=((-10., -0.), (1., 6.0))\n",
+        "\n",
+        "def callbackF(Xi,optimizer):\n",
+        "    global Nfeval\n",
+        "    global history\n",
+        "    loss=loss_func(Xi)\n",
+        "    grad=grad_loss_func(Xi)\n",
+        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
+        "    Nfeval += 1\n",
+        "    history=np.append(history,[Xi],axis=0)\n",
+        "\n",
+        "\n",
+        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "   1   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
+            "   2   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
+            "   3   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
+            "   4   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
+            "   5   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
+            "   6   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
+            "   7   -0.034966    4.965073    93898.349367    108.099959  2564.072969\n",
+            "   8   -0.034121    4.950125    93896.132090    120.124269 -2359.932024\n",
+            "   9   -0.044675    4.957270    93886.631516    100.305468  75.198587\n",
+            "  10   -0.095631    4.957070    93881.564259    98.091506  57.651556\n",
+            "  11   -1.323397    4.953307    93670.354084    521.297661  2346.429224\n",
+            "  12   -8.834048    4.924309    0.917340   -0.183921 -0.091864\n",
+            "  13   -8.830379    4.924320    0.916661   -0.185377 -0.092591\n",
+            "  14   -8.826692    4.924331    0.915974   -0.186850 -0.093327\n",
+            "  15   -8.822989    4.924342    0.915279   -0.188342 -0.094071\n",
+            "  16   -8.819268    4.924353    0.914574   -0.189851 -0.094825\n",
+            "  17   -8.815530    4.924364    0.913860   -0.191378 -0.095587\n",
+            "  18   -8.811773    4.924375    0.913137   -0.192924 -0.096359\n",
+            "  19   -8.807999    4.924387    0.912405   -0.194489 -0.097140\n",
+            "  20   -8.804206    4.924398    0.911663   -0.196074 -0.097931\n",
+            "  21   -8.800394    4.924409    0.910912   -0.197678 -0.098732\n",
+            "  22   -8.796564    4.924421    0.910150   -0.199302 -0.099542\n",
+            "  23   -8.792714    4.924432    0.909379   -0.200946 -0.100363\n",
+            "  24   -8.788844    4.924444    0.908597   -0.202611 -0.101194\n",
+            "  25   -8.784955    4.924455    0.907804   -0.204298 -0.102036\n",
+            "  26   -8.781045    4.924467    0.907001   -0.206005 -0.102888\n",
+            "  27   -8.777115    4.924478    0.906187   -0.207735 -0.103751\n",
+            "  28   -8.773164    4.924490    0.905362   -0.209488 -0.104626\n",
+            "  29   -8.769192    4.924502    0.904525   -0.211263 -0.105511\n",
+            "  30   -8.765199    4.924514    0.903676   -0.213061 -0.106409\n",
+            "  31   -8.761184    4.924526    0.902816   -0.214883 -0.107318\n",
+            "  32   -8.757146    4.924538    0.901943   -0.216729 -0.108239\n",
+            "  33   -8.753087    4.924550    0.901058   -0.218600 -0.109172\n",
+            "  34   -8.749004    4.924562    0.900161   -0.220496 -0.110118\n",
+            "  35   -8.744898    4.924574    0.899250   -0.222417 -0.111076\n",
+            "  36   -8.740769    4.924587    0.898326   -0.224365 -0.112048\n",
+            "  37   -8.736615    4.924599    0.897389   -0.226339 -0.113033\n",
+            "  38   -8.732438    4.924611    0.896438   -0.228341 -0.114031\n",
+            "  39   -8.728235    4.924624    0.895472   -0.230370 -0.115043\n",
+            "  40   -8.724008    4.924636    0.894493   -0.232427 -0.116069\n",
+            "  41   -8.719755    4.924649    0.893498   -0.234513 -0.117109\n",
+            "  42   -8.715476    4.924662    0.892489   -0.236629 -0.118164\n",
+            "  43   -8.711171    4.924675    0.891464   -0.238775 -0.119234\n",
+            "  44   -8.706839    4.924688    0.890423   -0.240951 -0.120319\n",
+            "  45   -8.702479    4.924701    0.889367   -0.243159 -0.121420\n",
+            "  46   -8.698093    4.924714    0.888293   -0.245398 -0.122536\n",
+            "  47   -8.693678    4.924727    0.887203   -0.247670 -0.123669\n",
+            "  48   -8.689234    4.924740    0.886096   -0.249975 -0.124818\n",
+            "  49   -8.684761    4.924753    0.884971   -0.252315 -0.125984\n",
+            "  50   -8.680259    4.924767    0.883828   -0.254689 -0.127167\n",
+            "  51   -8.675727    4.924780    0.882667   -0.257098 -0.128367\n",
+            "  52   -8.671164    4.924794    0.881486   -0.259544 -0.129586\n",
+            "  53   -8.666571    4.924808    0.880286   -0.262026 -0.130823\n",
+            "  54   -8.661945    4.924822    0.879067   -0.264546 -0.132078\n",
+            "  55   -8.657288    4.924836    0.877827   -0.267105 -0.133353\n",
+            "  56   -8.652598    4.924850    0.876566   -0.269703 -0.134647\n",
+            "  57   -8.647875    4.924864    0.875284   -0.272342 -0.135962\n",
+            "  58   -8.643118    4.924878    0.873980   -0.275021 -0.137296\n",
+            "  59   -8.638326    4.924892    0.872654   -0.277743 -0.138651\n",
+            "  60   -8.633500    4.924907    0.871305   -0.280507 -0.140028\n",
+            "  61   -8.628638    4.924921    0.869932   -0.283316 -0.141426\n",
+            "  62   -8.623740    4.924936    0.868536   -0.286169 -0.142847\n",
+            "  63   -8.618805    4.924951    0.867114   -0.289068 -0.144290\n",
+            "  64   -8.613833    4.924965    0.865667   -0.292015 -0.145756\n",
+            "  65   -8.608822    4.924980    0.864194   -0.295009 -0.147246\n",
+            "  66   -8.603773    4.924996    0.862695   -0.298052 -0.148760\n",
+            "  67   -8.598684    4.925011    0.861168   -0.301145 -0.150300\n",
+            "  68   -8.593555    4.925026    0.859613   -0.304289 -0.151864\n",
+            "  69   -8.588385    4.925042    0.858029   -0.307486 -0.153454\n",
+            "  70   -8.583173    4.925057    0.856416   -0.310737 -0.155071\n",
+            "  71   -8.577918    4.925073    0.854772   -0.314042 -0.156715\n",
+            "  72   -8.572621    4.925089    0.853097   -0.317404 -0.158386\n",
+            "  73   -8.567279    4.925105    0.851390   -0.320823 -0.160086\n",
+            "  74   -8.561893    4.925121    0.849650   -0.324301 -0.161814\n",
+            "  75   -8.556461    4.925137    0.847876   -0.327838 -0.163573\n",
+            "  76   -8.550982    4.925154    0.846067   -0.331438 -0.165361\n",
+            "  77   -8.545456    4.925170    0.844223   -0.335100 -0.167181\n",
+            "  78   -8.539882    4.925187    0.842342   -0.338826 -0.169032\n",
+            "  79   -8.534258    4.925204    0.840423   -0.342618 -0.170915\n",
+            "  80   -8.528585    4.925221    0.838465   -0.346478 -0.172832\n",
+            "  81   -8.522860    4.925238    0.836467   -0.350407 -0.174782\n",
+            "  82   -8.517083    4.925255    0.834429   -0.354406 -0.176768\n",
+            "  83   -8.511254    4.925273    0.832348   -0.358477 -0.178788\n",
+            "  84   -8.505370    4.925291    0.830223   -0.362622 -0.180845\n",
+            "  85   -8.499431    4.925308    0.828054   -0.366842 -0.182938\n",
+            "  86   -8.493435    4.925326    0.825838   -0.371140 -0.185070\n",
+            "  87   -8.487383    4.925345    0.823575   -0.375517 -0.187240\n",
+            "  88   -8.481272    4.925363    0.821263   -0.379974 -0.189450\n",
+            "  89   -8.475102    4.925381    0.818901   -0.384514 -0.191700\n",
+            "  90   -8.468870    4.925400    0.816487   -0.389139 -0.193992\n",
+            "  91   -8.462577    4.925419    0.814020   -0.393850 -0.196325\n",
+            "  92   -8.456221    4.925438    0.811497   -0.398649 -0.198702\n",
+            "  93   -8.449801    4.925457    0.808918   -0.403538 -0.201123\n",
+            "  94   -8.443314    4.925477    0.806281   -0.408520 -0.203588\n",
+            "  95   -8.436761    4.925497    0.803583   -0.413596 -0.206100\n",
+            "  96   -8.430140    4.925517    0.800823   -0.418768 -0.208658\n",
+            "  97   -8.423449    4.925537    0.797999   -0.424039 -0.211264\n",
+            "  98   -8.416687    4.925557    0.795110   -0.429410 -0.213919\n",
+            "  99   -8.409852    4.925578    0.792152   -0.434883 -0.216624\n",
+            " 100   -8.402944    4.925598    0.789123   -0.440461 -0.219379\n",
+            " 101   -8.395960    4.925619    0.786023   -0.446144 -0.222185\n",
+            " 102   -8.388899    4.925641    0.782848   -0.451937 -0.225044\n",
+            " 103   -8.381760    4.925662    0.779595   -0.457840 -0.227956\n",
+            " 104   -8.374541    4.925684    0.776263   -0.463855 -0.230922\n",
+            " 105   -8.367240    4.925706    0.772849   -0.469984 -0.233943\n",
+            " 106   -8.359856    4.925728    0.769351   -0.476229 -0.237019\n",
+            " 107   -8.352387    4.925751    0.765765   -0.482592 -0.240153\n",
+            " 108   -8.344832    4.925773    0.762089   -0.489075 -0.243343\n",
+            " 109   -8.337189    4.925796    0.758320   -0.495678 -0.246591\n",
+            " 110   -8.329456    4.925820    0.754455   -0.502404 -0.249897\n",
+            " 111   -8.321631    4.925843    0.750491   -0.509253 -0.253261\n",
+            " 112   -8.313713    4.925867    0.746425   -0.516227 -0.256685\n",
+            " 113   -8.305699    4.925891    0.742254   -0.523326 -0.260168\n",
+            " 114   -8.297589    4.925916    0.737974   -0.530551 -0.263710\n",
+            " 115   -8.289380    4.925941    0.733582   -0.537902 -0.267311\n",
+            " 116   -8.281071    4.925966    0.729074   -0.545380 -0.270970\n",
+            " 117   -8.272659    4.925991    0.724448   -0.552982 -0.274688\n",
+            " 118   -8.264144    4.926017    0.719699   -0.560709 -0.278463\n",
+            " 119   -8.255523    4.926043    0.714824   -0.568559 -0.282295\n",
+            " 120   -8.246794    4.926069    0.709819   -0.576530 -0.286181\n",
+            " 121   -8.237956    4.926096    0.704680   -0.584619 -0.290120\n",
+            " 122   -8.229007    4.926123    0.699404   -0.592822 -0.294111\n",
+            " 123   -8.219946    4.926150    0.693986   -0.601136 -0.298149\n",
+            " 124   -8.210770    4.926178    0.688424   -0.609553 -0.302232\n",
+            " 125   -8.201479    4.926206    0.682712   -0.618069 -0.306357\n",
+            " 126   -8.192071    4.926234    0.676848   -0.626675 -0.310518\n",
+            " 127   -8.182545    4.926263    0.670828   -0.635362 -0.314710\n",
+            " 128   -8.172900    4.926292    0.664648   -0.644119 -0.318928\n",
+            " 129   -8.163134    4.926322    0.658306   -0.652935 -0.323165\n",
+            " 130   -8.153248    4.926352    0.651797   -0.661793 -0.327412\n",
+            " 131   -8.143239    4.926382    0.645119   -0.670679 -0.331661\n",
+            " 132   -8.133109    4.926413    0.638269   -0.679573 -0.335901\n",
+            " 133   -8.122856    4.926444    0.631245   -0.688454 -0.340121\n",
+            " 134   -8.112481    4.926475    0.624046   -0.697296 -0.344306\n",
+            " 135   -8.101985    4.926507    0.616670   -0.706074 -0.348444\n",
+            " 136   -8.091368    4.926539    0.609116   -0.714756 -0.352515\n",
+            " 137   -8.080632    4.926571    0.601385   -0.723307 -0.356504\n",
+            " 138   -8.069779    4.926604    0.593477   -0.731689 -0.360387\n",
+            " 139   -8.058810    4.926637    0.585394   -0.739859 -0.364144\n",
+            " 140   -8.047730    4.926671    0.577140   -0.747770 -0.367748\n",
+            " 141   -8.036542    4.926705    0.568719   -0.755369 -0.371171\n",
+            " 142   -8.025250    4.926739    0.560135   -0.762600 -0.374384\n",
+            " 143   -8.013859    4.926773    0.551396   -0.769398 -0.377353\n",
+            " 144   -8.002377    4.926808    0.542512   -0.775698 -0.380042\n",
+            " 145   -7.990808    4.926843    0.533491   -0.781424 -0.382412\n",
+            " 146   -7.979163    4.926878    0.524347   -0.786498 -0.384423\n",
+            " 147   -7.967450    4.926914    0.515095   -0.790837 -0.386029\n",
+            " 148   -7.955679    4.926949    0.505751   -0.794351 -0.387185\n",
+            " 149   -7.943862    4.926985    0.496334   -0.796947 -0.387842\n",
+            " 150   -7.932013    4.927021    0.486867   -0.798527 -0.387949\n",
+            " 151   -7.920146    4.927057    0.477373   -0.798994 -0.387455\n",
+            " 152   -7.908276    4.927093    0.467878   -0.798245 -0.386307\n",
+            " 153   -7.908276    4.927093    0.467878   -0.798245 -0.386307\n",
+            " 154   -7.848408    4.927321    0.420584   -0.771958 -0.368458\n",
+            " 155   -7.790954    4.927540    0.377967   -0.699738 -0.326254\n",
+            " 156   -7.790954    4.927540    0.377967   -0.699738 -0.326254\n",
+            " 157   -7.747707    4.873301    0.365330   -0.675529 -0.304576\n",
+            " 158   -7.702004    4.842058    0.344823   -0.607186 -0.262349\n",
+            " 159   -7.702004    4.842058    0.344823   -0.607186 -0.262349\n",
+            " 160   -7.689707    4.844649    0.336946   -0.566972 -0.240863\n",
+            " 161   -7.523770    4.639694    0.295646   -0.324304 -0.087433\n",
+            " 162   -7.523770    4.639694    0.295646   -0.324304 -0.087433\n",
+            " 163   -7.497460    4.596363    0.290845   -0.299073 -0.069518\n",
+            " 164   -7.471506    4.551080    0.286141   -0.278315 -0.053724\n",
+            " 165   -7.445127    4.502834    0.281272   -0.260539 -0.039108\n",
+            " 166   -7.418223    4.451627    0.276118   -0.244945 -0.025218\n",
+            " 167   -7.390764    4.397522    0.270584   -0.230808 -0.011667\n",
+            " 168   -7.362676    4.340433    0.264566   -0.217403  0.001924\n",
+            " 169   -7.333884    4.280215    0.257962   -0.204001  0.015908\n",
+            " 170   -7.304319    4.216675    0.250661   -0.189832  0.030607\n",
+            " 171   -7.273930    4.149602    0.242550   -0.174036  0.046316\n",
+            " 172   -7.242692    4.078792    0.233516   -0.155613  0.063280\n",
+            " 173   -7.210634    4.004106    0.223464   -0.133386  0.081665\n",
+            " 174   -7.177870    3.925542    0.212335   -0.106008  0.101511\n",
+            " 175   -7.144635    3.843327    0.200143   -0.072064  0.122690\n",
+            " 176   -7.111326    3.758016    0.187002   -0.030269  0.144860\n",
+            " 177   -7.077665    3.671100    0.173264    0.029150  0.170001\n",
+            " 178   -7.046511    3.583248    0.159160    0.085919  0.191053\n",
+            " 179   -7.017504    3.496606    0.145148    0.149583  0.210275\n",
+            " 180   -7.017504    3.496606    0.145148    0.149583  0.210275\n",
+            " 181   -7.004204    3.172410    0.091821   -0.244363  0.112093\n",
+            " 182   -6.946453    2.529873    0.023259   -0.052009  0.082367\n",
+            " 183   -6.946453    2.529873    0.023259   -0.052009  0.082367\n",
+            " 184   -6.946453    2.529873    0.023259   -0.052009  0.082367\n",
+            " 185   -6.963564    2.426950    0.016870   -0.158539  0.078183\n",
+            " 186   -6.955020    2.424307    0.015632   -0.083556  0.073310\n",
+            " 187   -6.949597    2.321031    0.009054    0.045792  0.049340\n",
+            " 188   -6.962336    2.111678    0.002910    0.198519 -0.011404\n",
+            " 189   -6.975431    2.112659    0.001281    0.052680  0.011905\n",
+            " 190   -6.979861    2.112710    0.001150    0.006964  0.019095\n",
+            " 191   -6.979861    2.112710    0.001150    0.006964  0.019095\n",
+            " 192   -6.992903    2.033494    0.000107    0.009666  0.004379\n",
+            " 193   -6.993812    2.033407    0.000102    0.000528  0.005999\n",
+            " 194   -6.993812    2.033407    0.000102    0.000528  0.005999\n",
+            " 195   -6.999228    2.003365    0.000001    0.001429  0.000350\n",
+            " 196   -6.999351    2.003378    0.000001    0.000151  0.000591\n",
+            " 197   -6.999351    2.003378    0.000001    0.000151  0.000591\n",
+            " 198   -6.999869    2.000677    0.000000    0.000040  0.000117\n",
+            " 199   -6.999869    2.000677    0.000000    0.000040  0.000117\n",
+            " 200   -6.999973    2.000137    0.000000    0.000009  0.000024\n",
+            " 201   -6.999973    2.000137    0.000000    0.000009  0.000024\n",
+            " 202   -6.999995    2.000027    0.000000    0.000001  0.000005\n",
+            " 203   -6.999995    2.000027    0.000000    0.000001  0.000005\n",
+            " 204   -6.999999    2.000005    0.000000    0.000000  0.000001\n",
+            "`gtol` termination condition is satisfied.\n",
+            "Number of iterations: 204, function evaluations: 200, CG iterations: 378, optimality: 3.65e-09, constraint violation: 0.00e+00, execution time: 2.3e+01 s.\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "1RdHEuH8V3XG"
+      },
+      "source": [
+        "np.save(Folder+'/Images/MSEhistory_trust-constr_jac_tight_bounds.npy',history)\n",
+        "\n",
+        "#Bounds ((-10.,0.),(1.,10.))\n",
+        "#history_trust_constr_jac_loose_bounds=np.load(Folder+'/Images/MSEhistory_trust-constr_jac_loose_bounds.npy',allow_pickle=True)\n",
+        "\n",
+        "#Bounds ((-10.,0.),(1.,6.))\n",
+        "#history_trust_constr_jac_tight_bounds=np.load(Folder+'/Images/MSEhistory_trust-constr_jac_tight_bounds.npy',allow_pickle=True)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "mrPz5-9mWAT0"
+      },
+      "source": [
+        "loss_history=np.array([loss_func(x) for x in history])\n",
+        "grads_history=np.array([grad_loss_func(x) for x in history])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 597
+        },
+        "id": "EEYKmRFsWDjC",
+        "outputId": "c4811155-b419-4f35-951c-e202b139eb85"
+      },
+      "source": [
+        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
+        "\n",
+        "ax[0].plot(history[:,0],label='Fitting')\n",
+        "ax[0].set_title('Log(Amp)')\n",
+        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
+        "#ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
+        "#ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
+        "ax[0].legend()\n",
+        "\n",
+        "\n",
+        "\n",
+        "grads_history=np.array(grads_history)\n",
+        "loss_history=np.array(loss_history)\n",
+        "\n",
+        "ax[1].plot(np.abs(grads_history[:,0]))\n",
+        "ax[1].set_yscale('log')\n",
+        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
+        "\n",
+        "\n",
+        "ax[2].plot(history[:,1],label='Fitting')\n",
+        "ax[2].set_title('Beta')\n",
+        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
+        "ax[2].legend()\n",
+        "\n",
+        "ax[3].plot(np.abs(grads_history[:,1]))\n",
+        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
+        "ax[3].set_yscale('log')\n",
+        "\n",
+        "\n",
+        "\n",
+        "ax[4].plot(loss_history)\n",
+        "ax[4].set_yscale('log')\n",
+        "ax[4].set_title('Loss')\n",
+        "\n",
+        "fig.tight_layout()\n",
+        "fig.suptitle('weighted MAE loss',y=1.1)\n",
+        "\n",
+        "\n",
+        "\n",
+        "fig.add_subplot(111, frameon=False)\n",
+        "# hide tick and tick label of the big axis\n",
+        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
+        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1440x504 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bD5hAzxCJm3W"
+      },
+      "source": [
+        "# GRF unknown phase fitting"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-dLW1NAGJw6Z"
+      },
+      "source": [
+        "## Phase averaging GRF Loss"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "h4hh_s2Sn8UZ"
+      },
+      "source": [
+        "### For loop requirements"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "PwNS1h4UYFin"
+      },
+      "source": [
+        "#Random phases of GRF in Fourier space\n",
+        "def get_phase_realisation(npix,seed):\n",
+        "  \"A random array which has Gaussian magnitudes and Hermitian symmetry\"\n",
+        "  key=jax.random.PRNGKey(seed)\n",
+        "  #uneven number\n",
+        "  n=npix + 1 if (npix%2==0) else npix\n",
+        "  #2d grid\n",
+        "  size=[n]*2\n",
+        "\n",
+        "  magnitude=jax.random.normal(key, shape=size)\n",
+        "  phase=2 * jnp.pi * jax.random.uniform(key,shape=size)\n",
+        "\n",
+        "  #Make hermitian (why?)\n",
+        "  magnitude=(magnitude+magnitude[::-1,::-1])/jnp.sqrt(2)\n",
+        "  phase=(phase-phase[::-1,::-1])/2 + jnp.pi\n",
+        "\n",
+        "  phase_realisation=magnitude * (jnp.cos(phase) + 1j * jnp.sin(phase))\n",
+        "\n",
+        "  if (npix%2==0):\n",
+        "    #why?\n",
+        "    phase_realisation=phase_realisation[:-1,:-1]\n",
+        "\n",
+        "  return phase_realisation"
+      ],
+      "execution_count": 107,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "8i6IQnyIZDlk"
+      },
+      "source": [
+        "#The very jaxified GRF. params=(Amplitude,Power_slope)\n",
+        "def get_jaxified_GRF(params,seed,npix,pix_scl):\n",
+        "\n",
+        "  logA,beta=params\n",
+        "  A=jnp.power(10.,logA)\n",
+        "\n",
+        "  k_grid,dx=PowerBox_jax.get_k_grid_dx(npix,pix_scl)\n",
+        "  k_grid[npix//2,npix//2]=1\n",
+        "  mask_center=np.ones_like(k_grid)\n",
+        "  mask_center[npix//2,npix//2]=0\n",
+        "\n",
+        "\n",
+        "  sqrt_power_array=jnp.sqrt(A)*jnp.power(k_grid,-beta/2.)*mask_center\n",
+        "  phase_realisation=get_phase_realisation(npix,seed)\n",
+        "\n",
+        "  Fourier_image=sqrt_power_array*phase_realisation\n",
+        "\n",
+        "  Config_image=(npix**2)*jnp.fft.ifftshift(jnp.fft.ifftn(Fourier_image))\n",
+        "\n",
+        "  Config_image=PowerBox_jax._adjust_phase(Config_image,npix, pix_scl)\n",
+        "\n",
+        "  return jnp.real(Config_image)\n",
+        "\n",
+        "def get_jaxified_GRF_pure(GRF_params,GRF_seed):\n",
+        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)"
+      ],
+      "execution_count": 153,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "TYLpty8nn7Js"
+      },
+      "source": [
+        "def jax_map(f, xs):\n",
+        "  scan_func = lambda _,x: (1,f(x))\n",
+        "  ys=jax.lax.scan(scan_func,0,xs)[1]\n",
+        "  return ys"
+      ],
+      "execution_count": 151,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "S3EluzXNobij"
+      },
+      "source": [
+        "def test(GRF_params,GRF_seeds,npix,pix_scl):\n",
+        "  func=lambda GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
+        "  GRFs=jax_map(func,GRF_seeds)\n",
+        "  return jnp.mean(GRFs)\n",
+        "\n",
+        "test_pure=purify_function(test,GRF_seeds,npix,pix_scl)"
+      ],
+      "execution_count": 154,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "MdZYiqE7oeQu",
+        "outputId": "b63f5b67-c963-432a-91d0-af819eda02b7"
+      },
+      "source": [
+        "test_pure(GRF_params)"
+      ],
+      "execution_count": 155,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(-1.28369537e-20, dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 155
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_lwMC7B4of_d",
+        "outputId": "135adf9f-4714-4afe-a843-ae9f4788c7e5"
+      },
+      "source": [
+        "jax.grad(test_pure)(GRF_params)"
+      ],
+      "execution_count": 156,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([ 1.72057354e-20, -9.66918830e-22], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 156
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qyfGkFOooAOp"
+      },
+      "source": [
+        "### Fitting with phase averaging"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "d75MIP5doDsK"
+      },
+      "source": [
+        "def GRF_Loss_phase_averaging(GRF_params,GRF_seeds,jax_map,unperturbed_image,\n",
+        "             get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
+        "             compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
+        "\n",
+        "  #Mapping GRF generator over seeds\n",
+        "  get_GRF=lambda GRF_seed: get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
+        "  GRFs=jax_map(get_GRF,GRF_seeds)\n",
+        "\n",
+        "  #Mapping image generator over seeds\n",
+        "  simulated_images=jax_map(simulate_perturbed_image_pure,GRFs)\n",
+        "\n",
+        "  resids=simulated_images-unperturbed_image\n",
+        "  #Map over residuals for each seed\n",
+        "  resid_spectra=jax_map(compute_radial_spectrum_pure,resids)\n",
+        "\n",
+        "  Spectra_Losses=jax_map(Spectra_Loss_pure,resid_spectra)\n",
+        "\n",
+        "  return jnp.mean(Spectra_Losses)"
+      ],
+      "execution_count": 195,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "-31eRQoLoDxA"
+      },
+      "source": [
+        "#Pick spectrum loss type (weighted MSE or weighted MAE)\n",
+        "Spectra_Loss_pure=purify_function(Spectra_Loss_MAE,resid_true_spectrum)\n",
+        "\n",
+        "Seeds_number=10\n",
+        "#Seeds that do not contain the true one\n",
+        "GRF_seeds=np.arange(GRF_seed+1,GRF_seed+11)\n",
+        "\n",
+        "GRF_Loss_args=(GRF_seeds,jax_map,unperturbed_image,get_jaxified_GRF_pure,simulate_perturbed_image_pure,compute_radial_spectrum_pure,Spectra_Loss_pure)\n",
+        "\n",
+        "#Precompile GRF_Loss \n",
+        "GRF_Loss_pure=purify_function(GRF_Loss_phase_averaging,*GRF_Loss_args)"
+      ],
+      "execution_count": 196,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "2UO8dImipvQr"
+      },
+      "source": [
+        "Loss=(GRF_Loss_pure)(GRF_params)\n",
+        "Grad_Loss=jax.grad(GRF_Loss_pure)(GRF_params)"
+      ],
+      "execution_count": 199,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hQA2q9M5rKjX",
+        "outputId": "e8460148-f1c1-43e4-8058-cd4be3e9b6ab"
+      },
+      "source": [
+        "Loss"
+      ],
+      "execution_count": 200,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(0.23954485, dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 200
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eP1gVIFUrSMb",
+        "outputId": "0250fe9a-bead-447f-d011-43c9f88a3790"
+      },
+      "source": [
+        "Grad_Loss"
+      ],
+      "execution_count": 201,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([-0.11464667, -0.07556207], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 201
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "EqPuE3H5sgmu"
+      },
+      "source": [
+        "### Fitting with kwargs fitting"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "XXmZsSQgoD6a"
+      },
+      "source": [
+        "def GRF_Loss_image_fitting(GRF_params,GRF_seed,\n",
+        "                            get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
+        "                            simulate_smooth_image_pure,model_loss_function,parameters,\\\n",
+        "                            args_guess,learning_rate,max_iter,\\\n",
+        "                            compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
+        "\n",
+        "  GRF=get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
+        "\n",
+        "  simulated_image=simulate_perturbed_image_pure(GRF)\n",
+        "\n",
+        "  model_loss_function_pure=purify_function(model_loss_function,simulated_image,parameters,simulate_smooth_image_pure)\n",
+        "  model_loss_grad=jax.grad(model_loss_function_pure)\n",
+        "\n",
+        "  args_fit=gradient_descent(model_loss_grad,args_guess,max_iter,learning_rate)\n",
+        "  unperturbed_image=simulate_smooth_image_pure(parameters.args2kwargs(args_fit))\n",
+        "\n",
+        "\n",
+        "  resid=simulated_image-unperturbed_image\n",
+        "  #Map over residuals for each seed\n",
+        "  resid_spectrum=compute_radial_spectrum_pure(resid)\n",
+        "\n",
+        "  return Spectra_Loss_pure(resid_spectrum)\n",
+        "\n",
+        "args_guess=parameters.kwargs2args(kwargs_data)\n",
+        "learning_rate=1\n",
+        "max_iter=100\n",
+        "GRF_Loss_image_fitting_args=(GRF_seed,\n",
+        "                            get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
+        "                            simulate_smooth_image_pure,model_loss_function,parameters,\\\n",
+        "                            args_guess,learning_rate,max_iter,\\\n",
+        "                            compute_radial_spectrum_pure,Spectra_Loss_pure)"
+      ],
+      "execution_count": 319,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "EDawMoTCI8ez"
+      },
+      "source": [
+        "GRF_Loss_image_fitting_pure=purify_function(GRF_Loss_image_fitting,*GRF_Loss_image_fitting_args)"
+      ],
+      "execution_count": 320,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gtchu6gCJfTr",
+        "outputId": "b1834bae-dce1-4f58-cf79-a60c4764ac7d"
+      },
+      "source": [
+        "GRF_Loss_image_fitting_pure(GRF_params)"
+      ],
+      "execution_count": 321,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(103031.14678613, dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 321
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "39KS-8wQJ477",
+        "outputId": "df6773d1-6e67-4065-dfd9-22db4040cfdd"
+      },
+      "source": [
+        "jax.grad(GRF_Loss_image_fitting_pure)(GRF_params)"
+      ],
+      "execution_count": 322,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([14042.90651257, -3822.76900632], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 322
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "40fwmq-JI9t-"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "32PAha_9CQzS"
+      },
+      "source": [
+        "def gradient_descent(gradient_function,initial_guess,max_iter,learning_rate):\n",
+        "\n",
+        "  step_function= lambda _,X: X-learning_rate*gradient_function(X)\n",
+        "\n",
+        "  return jax.lax.fori_loop(0,max_iter,step_function,initial_guess)"
+      ],
+      "execution_count": 285,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "CifbBkZPCS6M"
+      },
+      "source": [
+        "simulate_smooth_image??"
+      ],
+      "execution_count": 286,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "rPiuM7_zCVUM"
+      },
+      "source": [
+        "parameters=get_parameters(kwargs_data,lens_mass_model_list,source_light_model_list)\n",
+        "def smooth_image_from_args(args,parameters,smooth_lens_image):\n",
+        "    kwargs=parameters.args2kwargs(args)\n",
+        "    return smooth_lens_image.model(**kwargs)\n",
+        "\n",
+        "def lens_model_loss_function(args_model,true_image,smooth_image_from_args):\n",
+        "    model_image=smooth_image_from_args(args_model,parameters,smooth_lens_image)\n",
+        "    return jnp.mean(jnp.power(true_image-model_image,2))\n",
+        "\n",
+        "lens_model_loss_function_pure=purify_function(lens_model_loss_function,perturbed_image,smooth_image_from_args)\n",
+        "lens_model_loss_function_grad=jax.grad(lens_model_loss_function_pure)"
+      ],
+      "execution_count": 298,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "fadZy3ZkEP_D"
+      },
+      "source": [
+        "def test_func(perturbed_image):\n",
+        "\n",
+        "  lens_model_loss_function_pure=purify_function(lens_model_loss_function,perturbed_image,smooth_image_from_args)\n",
+        "  lens_model_loss_function_grad=jax.grad(lens_model_loss_function_pure)\n",
+        "\n",
+        "  args_fit=gradient_descent(lens_model_loss_function_grad,args_data,100,1)\n",
+        "  return jnp.mean(args_fit)"
+      ],
+      "execution_count": 307,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Kele9N8FE3fO",
+        "outputId": "f7207e47-76b9-4530-a4b3-535446ddfc00"
+      },
+      "source": [
+        "args_fit=test_func(perturbed_image)\n",
+        "args_fit"
+      ],
+      "execution_count": 308,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(1.06525433, dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 308
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "UrWOe7p9FZLr",
+        "outputId": "58e62f9f-6edc-414b-eafc-f719926a01dc"
+      },
+      "source": [
+        "image_grad=jax.grad(test_func)(perturbed_image)\n",
+        "image_grad"
+      ],
+      "execution_count": 309,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([[ 2.59096499e-06,  2.58111101e-06,  2.56222307e-06, ...,\n",
+              "              -8.61087507e-06, -7.92913190e-06, -7.43262708e-06],\n",
+              "             [ 2.75437164e-06,  2.74746110e-06,  2.73234056e-06, ...,\n",
+              "              -8.69403412e-06, -7.98733500e-06, -7.47313434e-06],\n",
+              "             [ 2.98069676e-06,  2.97804598e-06,  2.96840119e-06, ...,\n",
+              "              -8.78917836e-06, -8.04905331e-06, -7.51119510e-06],\n",
+              "             ...,\n",
+              "             [ 1.25822568e-07, -5.55769577e-08, -3.11478599e-07, ...,\n",
+              "               9.77560269e-06,  9.66589213e-06,  9.57398842e-06],\n",
+              "             [-1.54353252e-07, -3.38898415e-07, -5.98558393e-07, ...,\n",
+              "               8.94754429e-06,  8.86587527e-06,  8.79516182e-06],\n",
+              "             [-3.53569546e-07, -5.39963603e-07, -8.01745397e-07, ...,\n",
+              "               8.35417245e-06,  8.29189050e-06,  8.23586507e-06]],            dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 309
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 285
+        },
+        "id": "wodCIlloGCf5",
+        "outputId": "a98fed5d-d743-4180-ba7e-65ab988c1d77"
+      },
+      "source": [
+        "plt.imshow(image_grad)"
+      ],
+      "execution_count": 310,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.image.AxesImage at 0x7f88db8b8e50>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 310
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "L-dYxfZAD8rp",
+        "outputId": "9c2d5510-c8e3-4e6d-e078-abcc61251b39"
+      },
+      "source": [
+        "lens_model_loss_function_grad(args_data)"
+      ],
+      "execution_count": 300,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([ 6.81316887e-04, -1.41564855e-04, -1.82857258e-04,\n",
+              "             -1.92534138e-04,  5.46093013e-04,  3.84206441e-04,\n",
+              "              5.47206705e-04,  1.31644039e-05, -1.44542959e-05,\n",
+              "              1.85214443e-04,  9.72754374e-05, -3.12118343e-05,\n",
+              "              4.04593418e-04, -4.09870720e-04], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 300
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VACfJ083Dpln",
+        "outputId": "f369fdf4-e3ad-446f-f668-009ff51d6bd5"
+      },
+      "source": [
+        "args_fit-args_data"
+      ],
+      "execution_count": 304,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([-0.01160592, -0.00032954, -0.00113101,  0.00300114,\n",
+              "             -0.00878816, -0.00072539, -0.00276271, -0.00088603,\n",
+              "              0.00280663, -0.01477706, -0.00750633,  0.00506102,\n",
+              "             -0.00503509,  0.00623905], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 304
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "FmREV3e3C_B7"
+      },
+      "source": [
+        "args_data=parameters.kwargs2args(kwargs_data)"
+      ],
+      "execution_count": 292,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ErHLhjC2DDAq",
+        "outputId": "a15b8395-0297-46d8-f8aa-3641a2bee838"
+      },
+      "source": [
+        "args_data"
+      ],
+      "execution_count": 293,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([ 1.6 ,  0.15, -0.04,  0.  ,  0.  , -0.01,  0.03, 10.  ,\n",
+              "              1.2 ,  1.5 ,  0.07, -0.1 ,  0.4 ,  0.15], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 293
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "N5DJI4tyDDHQ"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Jjv0mq_ADDOe"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bmUiBFrpDDWB"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "GTxXXS03DDeN"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "u4mwYAcqoD_k"
+      },
+      "source": [
+        "def minimize_function(function,grad_func,initial_guess,args,max_iter,learning_rate,jax_map):\n",
+        "\n",
+        "    history=np.zeros(learning_rate)\n",
+        "    history[0]=initial_guess\n",
+        "\n",
+        "    def step(arg,max_iter,learning_rate):\n",
+        "      i,X=arg\n",
+        "      new_X=X-learning_rate*grad_func(X)\n",
+        "      new_arg=(i+1,new_X)\n",
+        "\n",
+        "      Bool_end=((i+1)>=max_iter)\n",
+        "\n",
+        "      return_answer=lambda _,X: return new_X\n",
+        "      continue_cycle=lambda i,X: return step(new_arg,max_iter,learning_rate)\n",
+        "\n",
+        "      return jax.lax.cond(Bool_end,return_answer,continue_cycle,new_arg)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "xWOnrH6AoEEW"
+      },
+      "source": [
+        "def grad_descent(arg,grad_func,max_iter,learning_rate):\n",
+        "      i,X=arg\n",
+        "      new_X=X-learning_rate*grad_func(X)\n",
+        "\n",
+        "      Bool_end=((i+1)>=max_iter)\n",
+        "\n",
+        "      #Return optimization argument\n",
+        "      #return_answer=lambda _,new_X: new_X\n",
+        "      #Recursively continue descent\n",
+        "      #continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\n",
+        "      continue_cycle=lambda new_arg: grad_descent(new_arg,grad_func,max_iter,learning_rate)\n",
+        "      return_answer=lambda arg: arg\n",
+        "\n",
+        "      return jax.lax.cond(Bool_end,return_answer,continue_cycle,(i+1,new_X))"
+      ],
+      "execution_count": 238,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "frVLdzWhyZQ-"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": 258,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lJeVBxP457EJ"
+      },
+      "source": [
+        "#### Gradient descent"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "fXB8444O3ypH"
+      },
+      "source": [
+        "def test_func(model,data):\n",
+        "  return jnp.abs(model-data)\n",
+        "\n",
+        "learning_rate=0.01\n",
+        "max_iter=100\n",
+        "\n",
+        "\n",
+        "def test(data):\n",
+        "\n",
+        "  test_func_pure=lambda model: test_func(model,10.)\n",
+        "  test_func_grad=jax.grad(test_func_pure)\n",
+        "\n",
+        "  step= lambda i,X: X-learning_rate*test_func_grad(X)\n",
+        "\n",
+        "  model=jax.lax.fori_loop(0,max_iter,step,data**2)\n",
+        "  return model"
+      ],
+      "execution_count": 271,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "LKkOOU3G9cUt"
+      },
+      "source": [
+        "def gradient_descent(gradient_function,initial_guess,max_iter,learning_rate):\n",
+        "\n",
+        "  step_function= lambda _,X: X-learning_rate*gradient_function(X)\n",
+        "\n",
+        "  return jax.lax.fori_loop(0,max_iter,step_function,initial_guess)"
+      ],
+      "execution_count": 275,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "1mkGf5MlB-xT"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": 284,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "LE-E8EBb_HxT"
+      },
+      "source": [
+        "test_func_pure=lambda model: test_func(model,10.)\n",
+        "test_func_grad=jax.grad(test_func_pure)"
+      ],
+      "execution_count": 276,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_7sGEmjE_Mcg",
+        "outputId": "80ac14f1-3265-4bae-9380-1c16c04e6524"
+      },
+      "source": [
+        "gradient_descent_pure=lambda initial_guess: gradient_descent(test_func_grad,initial_guess,100,0.1)\n",
+        "jax.grad(gradient_descent_pure)(0.)"
+      ],
+      "execution_count": 280,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(1., dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 280
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "AH9J04tT4dJ3",
+        "outputId": "21ea5379-5c0e-4de4-e9ea-f8ddb2699c4f"
+      },
+      "source": [
+        "jax.grad(test)(2.)"
+      ],
+      "execution_count": 273,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(4., dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 273
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Cc4vnI5Y54wt",
+        "outputId": "2ee81d2d-63fb-4008-c855-7fcc814bd843"
+      },
+      "source": [
+        "jax.grad(test)(3.)"
+      ],
+      "execution_count": 274,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(6., dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 274
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9sW9lTHG4fmI",
+        "outputId": "1930ad18-d977-446c-a618-e1ec4fc5f54e"
+      },
+      "source": [
+        "test(2.)"
+      ],
+      "execution_count": 269,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(3., dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 269
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "oJVkTmAP4fsb"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "dLDY3odJ4fzU"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "5b9kWwxS3JBm"
+      },
+      "source": [
+        "\n",
+        "\n",
+        "def step(i,X):\n",
+        "  return X-learning_rate*test_func_grad(X)\n",
+        "\n",
+        "X=jax.lax.fori_loop(0,max_iter,step,0.)"
+      ],
+      "execution_count": 244,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "TwIiO55T3Y15",
+        "outputId": "d4be6e04-f863-45fd-daf6-97480c8b4b32"
+      },
+      "source": [
+        "X"
+      ],
+      "execution_count": 245,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(10., dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 245
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "uSzqgO3vyZWd",
+        "outputId": "622fcb28-f919-49cd-e8f8-3b518140e296"
+      },
+      "source": [
+        "test_func_grad(5.)"
+      ],
+      "execution_count": 232,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(-1., dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 232
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 494
+        },
+        "id": "R-Qed2D_yZcd",
+        "outputId": "e871725d-f1e1-43ea-8bd3-c425b5dcfd21"
+      },
+      "source": [
+        "init_guess=(0,0.)\n",
+        "grad_descent(init_guess,test_func_grad,10,0.1)"
+      ],
+      "execution_count": 239,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "RecursionError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-239-c9fbb723c0c1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0minit_guess\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit_guess\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtest_func_grad\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m      2\u001b[0m       \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m       \u001b[0mnew_X\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mgrad_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    796\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mgrad_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 797\u001b[0;31m     \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue_and_grad_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    798\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mvalue_and_grad_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    870\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 871\u001b[0;31m       \u001b[0mans\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvjp_py\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_vjp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mdyn_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreduce_axes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    872\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_vjp\u001b[0;34m(fun, has_aux, reduce_axes, *primals)\u001b[0m\n\u001b[1;32m   2136\u001b[0m     out_primal, out_vjp = ad.vjp(\n\u001b[0;32m-> 2137\u001b[0;31m         flat_fun, primals_flat, reduce_axes=reduce_axes)\n\u001b[0m\u001b[1;32m   2138\u001b[0m     \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mvjp\u001b[0;34m(traceable, primals, has_aux, reduce_axes)\u001b[0m\n\u001b[1;32m    114\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m     \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinearize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mlinearize\u001b[0;34m(traceable, *primals, **kwargs)\u001b[0m\n\u001b[1;32m    101\u001b[0m   \u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m   \u001b[0mout_primals_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tangents_pvals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr\u001b[0;34m(fun, pvals, instantiate)\u001b[0m\n\u001b[1;32m    504\u001b[0m     \u001b[0mfun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstantiate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 505\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    506\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-231-45f6ccfdccea>\u001b[0m in \u001b[0;36mtest_func\u001b[0;34m(arg)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m__sub__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    510\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__radd__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_radd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 511\u001b[0;31m   \u001b[0;32mdef\u001b[0m \u001b[0m__sub__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sub\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    512\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__rsub__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rsub\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36mdeferring_binary_op\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m   5923\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5924\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mbinary_op\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5925\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mdeferring_binary_op\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mcache_miss\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    407\u001b[0m         \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 408\u001b[0;31m         donated_invars=donated_invars, inline=inline)\n\u001b[0m\u001b[1;32m    409\u001b[0m     \u001b[0mout_pytree_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    317\u001b[0m                   if update_params else params)\n\u001b[0;32m--> 318\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mnonzero_tangents\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mnew_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m     \u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree_def\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    194\u001b[0m       jaxpr, out_pvals, consts, env_tracers = self.partial_eval(\n\u001b[0;32m--> 195\u001b[0;31m           f, in_pvals, app, instantiate=False)\n\u001b[0m\u001b[1;32m    196\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap_primitive\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mpartial_eval\u001b[0;34m(self, f, pvals, app, instantiate)\u001b[0m\n\u001b[1;32m    302\u001b[0m     \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial_eval_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 303\u001b[0;31m     \u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0min_consts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    304\u001b[0m     \u001b[0mout_consts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msplit_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjaxpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstvars\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m   1071\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_sublevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1072\u001b[0;31m       \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1073\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'inline'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x1, x2)\u001b[0m\n\u001b[1;32m    424\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 425\u001b[0;31m     \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlax_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0m_promote_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumpy_fn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    426\u001b[0m   \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minline\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_args\u001b[0;34m(fun_name, *args)\u001b[0m\n\u001b[1;32m    326\u001b[0m   \u001b[0m_check_no_float0s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 327\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_promote_shapes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0m_promote_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    328\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_dtypes\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/lax.py\u001b[0m in \u001b[0;36m_convert_element_type\u001b[0;34m(operand, new_dtype, weak_type)\u001b[0m\n\u001b[1;32m    458\u001b[0m     return convert_element_type_p.bind(operand, new_dtype=new_dtype,\n\u001b[0;32m--> 459\u001b[0;31m                                        weak_type=new_weak_type)\n\u001b[0m\u001b[1;32m    460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m    264\u001b[0m     \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 265\u001b[0;31m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    266\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfull_lower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    142\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 143\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefault_process_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    144\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mdefault_process_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    149\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    151\u001b[0m     \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minstantiate_const\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m    264\u001b[0m     \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 265\u001b[0;31m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    266\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfull_lower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m   1063\u001b[0m     \u001b[0minvars\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1064\u001b[0;31m     \u001b[0moutvars\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmakevar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1065\u001b[0m     \u001b[0meqn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_jaxpr_eqn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutvars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msource_info\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36msafe_map\u001b[0;34m(f, *args)\u001b[0m\n\u001b[1;32m     40\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'length mismatch: {}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mmakevar\u001b[0;34m(self, tracer)\u001b[0m\n\u001b[1;32m   1040\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1041\u001b[0;31m     \u001b[0mvar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtracer_to_var\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnewvar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1042\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mvar\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mnewvar\u001b[0;34m(self, aval)\u001b[0m\n\u001b[1;32m    957\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mnewvar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 958\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgensym\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    959\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(aval)\u001b[0m\n\u001b[1;32m    195\u001b[0m   \u001b[0mcounter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 196\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0maval\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mVar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msuffix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    197\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, count, suffix, aval)\u001b[0m\n\u001b[1;32m    159\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msuffix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuffix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 160\u001b[0;31m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mraise_to_shaped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mraise_to_shaped\u001b[0;34m(aval, weak_type)\u001b[0m\n\u001b[1;32m   1225\u001b[0m     \u001b[0mhandler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mraise_to_shaped_mappings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtyp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1226\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mhandler\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mhandler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1227\u001b[0m   \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(aval, weak_type)\u001b[0m\n\u001b[1;32m   1234\u001b[0m   ShapedArray: lambda aval, weak_type: ShapedArray(\n\u001b[0;32m-> 1235\u001b[0;31m       aval.shape, aval.dtype, weak_type, aval.named_shape)\n\u001b[0m\u001b[1;32m   1236\u001b[0m }\n",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: RecursionError: maximum recursion depth exceeded\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
+            "\nThe above exception was the direct cause of the following exception:\n",
+            "\u001b[0;31mRecursionError\u001b[0m                            Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-239-c9fbb723c0c1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0minit_guess\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit_guess\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtest_func_grad\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m       \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m       \u001b[0mnew_X\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m       \u001b[0mBool_end\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m>=\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-231-45f6ccfdccea>\u001b[0m in \u001b[0;36mtest_func\u001b[0;34m(arg)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mtest_func_grad\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36mdeferring_binary_op\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m   5922\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_scalar_types\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0m_arraylike_types\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTracer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5923\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5924\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mbinary_op\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5925\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mdeferring_binary_op\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5926\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x1, x2)\u001b[0m\n\u001b[1;32m    423\u001b[0m     \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlax_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0m_promote_args_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumpy_fn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    424\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 425\u001b[0;31m     \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlax_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0m_promote_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumpy_fn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    426\u001b[0m   \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minline\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    427\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mlax_doc\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_args\u001b[0;34m(fun_name, *args)\u001b[0m\n\u001b[1;32m    325\u001b[0m   \u001b[0m_check_arraylike\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    326\u001b[0m   \u001b[0m_check_no_float0s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 327\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_promote_shapes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0m_promote_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    328\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    329\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_promote_args_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_dtypes\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m    271\u001b[0m     \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lattice_result_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    275\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_promote_dtypes_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    271\u001b[0m     \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lattice_result_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    275\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_promote_dtypes_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "1pyNFHoDyZh_"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "RQ7sOkt4oEI6"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "eRKAWvtfoBu-"
+      },
+      "source": [
+        "### Else"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "DpTFv0NqbDr2"
+      },
+      "source": [
+        "#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\n",
+        "g = lambda _,GRF_seed: (1,get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl))\n",
+        "GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])"
+      ],
+      "execution_count": 130,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "mrKvivQBbXIa"
+      },
+      "source": [
+        "def test(GRF_params,GRF_seeds,npix,pix_scl):\n",
+        "  g = lambda _,GRF_seed: (1,get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl))\n",
+        "  GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])\n",
+        "  return jnp.mean(GRFs)\n",
+        "\n",
+        "test_pure=purify_function(test,GRF_seeds,npix,pix_scl)"
+      ],
+      "execution_count": 137,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "scOH4r7hm2ZW"
+      },
+      "source": [
+        "def jax_map(f, xs):\n",
+        "  scan_func = lambda _,x: (1,f(x))\n",
+        "  ys=jax.lax.scan(scan_func,0,xs)[1]\n",
+        "  return ys"
+      ],
+      "execution_count": 144,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "4QhVro5unTCM"
+      },
+      "source": [
+        "func=lambda GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
+        "GRFs=jax_map(func,GRF_seeds)"
+      ],
+      "execution_count": 145,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Fjm38tG2nj5k"
+      },
+      "source": [
+        "def test(GRF_params,GRF_seeds,npix,pix_scl):\n",
+        "  func=lambda GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
+        "  GRFs=jax_map(func,GRF_seeds)\n",
+        "  return jnp.mean(GRFs)\n",
+        "\n",
+        "test_pure=purify_function(test,GRF_seeds,npix,pix_scl)"
+      ],
+      "execution_count": 148,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "iB3ksFlDnxkF",
+        "outputId": "ab046d4f-f136-4916-d45d-32851034fd0a"
+      },
+      "source": [
+        "test_pure(GRF_params)"
+      ],
+      "execution_count": 149,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(-1.28369537e-20, dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 149
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "MVRYBU4Qn22n",
+        "outputId": "ae4c995e-163d-4a4a-d672-113d35e48ab5"
+      },
+      "source": [
+        "jax.grad(test_pure)(GRF_params)"
+      ],
+      "execution_count": 150,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([ 1.72057354e-20, -9.66918830e-22], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 150
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xfa7IKSRb-S7",
+        "outputId": "ae12cebd-366c-473a-f35f-c0117f6dc916"
+      },
+      "source": [
+        "test_pure(GRF_params)"
+      ],
+      "execution_count": 138,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(-1.28369537e-20, dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 138
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5pQNIBT9cAz_",
+        "outputId": "8866c1c0-ba91-4745-8b42-09e0d1e6521d"
+      },
+      "source": [
+        "jax.grad(test_pure)(GRF_params)"
+      ],
+      "execution_count": 141,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([ 1.72057354e-20, -9.66918830e-22], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 141
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "cc-x2boccIpg"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "TQ836WRCmoH2"
+      },
+      "source": [
+        "def GRF_Loss_phase_averaging(GRF_params,GRF_seeds,unperturbed_image,\n",
+        "             get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
+        "             compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
+        "\n",
+        "\n",
+        "  GRFs=get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
+        "\n",
+        "  simulated_image=simulate_perturbed_image_pure(GRF)\n",
+        "\n",
+        "  resid=simulated_image-unperturbed_image\n",
+        "  resid_spectrum=compute_radial_spectrum_pure(resid)\n",
+        "\n",
+        "  return Spectra_Loss_pure(resid_spectrum)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "7aTuADSOmoMF"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "tXOmcDw8moQQ"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "qveWV_eKmoUi"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "WJRB8qr6moZC"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "dXbbfmrYboHN",
+        "outputId": "1d6b50b3-b954-4e40-a270-0e199b288faa"
+      },
+      "source": [
+        "test(GRF_params,GRF_seeds,npix,pix_scl)"
+      ],
+      "execution_count": 136,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray(-2.07125983e-19, dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 136
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ENgEPaBibJ-z",
+        "outputId": "a9d0b50f-a91c-472d-8641-d98f90095fc4"
+      },
+      "source": [
+        "GRFs.shape"
+      ],
+      "execution_count": 132,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(8, 100, 100)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 132
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Dk5XPYDzbPEn"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "PIOo6qilbPIl"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_2AW63TKatXN",
+        "outputId": "0c62efe7-5e6b-441a-8c6f-e94c1860e608"
+      },
+      "source": [
+        "test(GRF_params,GRF_seed)"
+      ],
+      "execution_count": 127,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([[ 3.25806937e-04, -1.39600163e-02, -2.37375768e-02, ...,\n",
+              "              -8.88541266e-03, -3.23081929e-03, -2.46492310e-03],\n",
+              "             [-7.24474457e-03, -1.77732719e-02, -2.79357125e-02, ...,\n",
+              "               1.05281659e-03, -4.40623246e-03, -2.26561027e-04],\n",
+              "             [-1.01756208e-02, -1.89674044e-02, -4.25634981e-02, ...,\n",
+              "              -1.32873739e-03, -6.52506532e-03,  5.27138495e-03],\n",
+              "             ...,\n",
+              "             [-9.65185178e-03, -6.77607686e-03, -1.10149004e-02, ...,\n",
+              "               1.62030230e-05, -7.61569564e-03, -1.78757703e-02],\n",
+              "             [-1.67147186e-03, -5.47283177e-03, -1.16820204e-02, ...,\n",
+              "               1.46123272e-02, -1.07998702e-02, -1.30477015e-02],\n",
+              "             [ 6.94097951e-03,  4.94321425e-03, -1.39605537e-02, ...,\n",
+              "               1.31260745e-02,  8.41794504e-03,  8.53962036e-03]],            dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 127
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 562
+        },
+        "id": "u-N4LsOaaXyg",
+        "outputId": "1a5f4cf7-68ed-4b2f-d484-c968750fcbc3"
+      },
+      "source": [
+        "vv = lambda GRF_seed, GRF_params: test(GRF_params,GRF_seed)\n",
+        "mv = jax.vmap(vv, (0, None), 0)\n",
+        "matrix=np.outer([5,6],GRF_seed)\n",
+        "mv(matrix,GRF_params)"
+      ],
+      "execution_count": 128,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "TypeError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mbatched_fun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1286\u001b[0m         \u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mflatten_axes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"vmap out_axes\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_axes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1287\u001b[0;31m     ).call_wrapped(*args_flat)\n\u001b[0m\u001b[1;32m   1288\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_seed, GRF_params)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mcache_miss\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    407\u001b[0m         \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 408\u001b[0;31m         donated_invars=donated_invars, inline=inline)\n\u001b[0m\u001b[1;32m    409\u001b[0m     \u001b[0mout_pytree_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/batching.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    158\u001b[0m       \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch_subtrace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 159\u001b[0;31m       \u001b[0mvals_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    160\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mBatchTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvals_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    612\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 613\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    614\u001b[0m   \u001b[0mprocess_map\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_call_impl\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m    619\u001b[0m   compiled_fun = _xla_callable(fun, device, backend, name, donated_invars,\n\u001b[0;32m--> 620\u001b[0;31m                                *unsafe_map(arg_spec, args))\n\u001b[0m\u001b[1;32m    621\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mmemoized_fun\u001b[0;34m(fun, *args)\u001b[0m\n\u001b[1;32m    261\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 262\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    263\u001b[0m       \u001b[0mcache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mans\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_callable\u001b[0;34m(fun, device, backend, name, donated_invars, *arg_specs)\u001b[0m\n\u001b[1;32m    696\u001b[0m   jaxpr, out_avals, consts = pe.trace_to_jaxpr_final(\n\u001b[0;32m--> 697\u001b[0;31m       fun, abstract_args, pe.debug_info_final(fun, \"jit\"))\n\u001b[0m\u001b[1;32m    698\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTracer\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_final\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1284\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_sublevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1285\u001b[0;31m       \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1286\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_params, GRF_seed)\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;31m#test=purify_function(get_jaxified_GRF,GRF_seed,npix,pix_scl)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m     13\u001b[0m   \u001b[0msqrt_power_array\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_grid\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mbeta\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mmask_center\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-107-4e83d035625d>\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m      3\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m   \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPRNGKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m   \u001b[0;31m#uneven number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/random.py\u001b[0m in \u001b[0;36mPRNGKey\u001b[0;34m(seed)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"PRNGKey seed must be a scalar; got {seed!r}.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missubdtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minteger\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: TypeError: PRNGKey seed must be a scalar; got Traced<ShapedArray(int64[1])>with<BatchTrace(level=1/1)>\n  with val = Traced<ShapedArray(int64[2,1])>with<DynamicJaxprTrace(level=0/1)>\n       batch_dim = 0.\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
+            "\nThe above exception was the direct cause of the following exception:\n",
+            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mmv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_seed, GRF_params)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mmv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_params, GRF_seed)\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;31m#test=purify_function(get_jaxified_GRF,GRF_seed,npix,pix_scl)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m   \u001b[0msqrt_power_array\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_grid\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mbeta\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mmask_center\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m   \u001b[0mFourier_image\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msqrt_power_array\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mphase_realisation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-107-4e83d035625d>\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m   \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPRNGKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m   \u001b[0;31m#uneven number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m   \u001b[0mn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnpix\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mnpix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/random.py\u001b[0m in \u001b[0;36mPRNGKey\u001b[0;34m(seed)\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0mseed_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"PRNGKey seed must be a scalar; got {seed!r}.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missubdtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minteger\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"PRNGKey seed must be an integer; got {seed!r}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mTypeError\u001b[0m: PRNGKey seed must be a scalar; got Traced<ShapedArray(int64[1])>with<BatchTrace(level=1/1)>\n  with val = Traced<ShapedArray(int64[2,1])>with<DynamicJaxprTrace(level=0/1)>\n       batch_dim = 0."
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "b2CUB3OSaX2P"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "yBQ2qUpKaX5s"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "uKeoLcUrZeFk",
+        "outputId": "908dfa35-779b-4ce4-d8a6-4cc69ae3b85b"
+      },
+      "source": [
+        "jax.grad(jax.jit(lambda GRF_params: np.std(test(GRF_params))))(GRF_params)"
+      ],
+      "execution_count": 124,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([0.01728465, 0.00479345], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 124
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "RaLjUeugX4z4"
+      },
+      "source": [
+        "key=random.PRNGKey(0)\n",
+        "jax.random.normal()"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 164
+        },
+        "id": "BTkoFv62XztY",
+        "outputId": "df120cc1-4935-4b16-9d94-a8c4ef7c51fd"
+      },
+      "source": [
+        "jnp.random.normal(size=(1,2))"
+      ],
+      "execution_count": 100,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "AttributeError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-100-2db52f4c04f6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;31mAttributeError\u001b[0m: module 'jax.numpy' has no attribute 'random'"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "6TMBZ0ALVbd7"
+      },
+      "source": [
+        "@jax.partial(jax.jit,static_argnums=(1,))\n",
+        "def get_jaxified_GRF_pure(GRF_params,GRF_seed):\n",
+        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)"
+      ],
+      "execution_count": 99,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "gqn2oPLGTuzO"
+      },
+      "source": [
+        "vv = lambda x, y: print(x,y)\n",
+        "mv = jax.vmap(vv, (0, None), 0)\n",
+        "mm = jax.vmap(mv, (None, 1), 1)"
+      ],
+      "execution_count": 96,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HGXNzadJVJwI",
+        "outputId": "ed1109ae-49d2-48d4-aa53-1314e54e01df"
+      },
+      "source": [
+        "vv(GRF_seed,GRF_params)"
+      ],
+      "execution_count": 97,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "1 [-7.  2.]\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "azV7s-WJVZuM"
+      },
+      "source": [
+        "get_jaxified_GRF_pure??"
+      ],
+      "execution_count": 89,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "01PF9zD9VN_V",
+        "outputId": "2caef2fd-7974-4baf-f40f-ede5fe3bcd2f"
+      },
+      "source": [
+        "matrix=np.outer([5,6],GRF_seed)\n",
+        "mv(matrix,GRF_params)"
+      ],
+      "execution_count": 98,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Traced<ShapedArray(int64[1])>with<BatchTrace(level=1/0)>\n",
+            "  with val = array([[5],\n",
+            "                    [6]])\n",
+            "       batch_dim = 0 [-7.  2.]\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "e9Nqu-Z6Tu8H",
+        "outputId": "9e99aa6f-2a8a-49e2-941a-2f4d01a7f37b"
+      },
+      "source": [
+        "arr1=1\n",
+        "matrix=np.outer([5,6],arr1)\n",
+        "arr2=np.array([2,3,4])\n",
+        "vv(arr1,arr2)"
+      ],
+      "execution_count": 83,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([2, 3, 4])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 83
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "I_P9ZWosUWuB",
+        "outputId": "a4d4a557-4839-43ec-fb05-67110d319346"
+      },
+      "source": [
+        "mv(matrix,arr2)"
+      ],
+      "execution_count": 84,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([[10, 15, 20],\n",
+              "             [12, 18, 24]], dtype=int64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 84
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "c-INyoeRTvAX"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ogS4UzLdKIBQ"
+      },
+      "source": [
+        "simulate_perturbed_image_pure=purify_function(simulate_perturbed_image,kwargs_data,perturbed_lens_image,x_coords,y_coords)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "3efGrwhgPddT"
+      },
+      "source": [
+        "def get_jaxified_GRF_traced(GRF_params,GRF_seed):\n",
+        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)"
+      ],
+      "execution_count": 64,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "se85H3n9ResR",
+        "outputId": "154bdc67-c8d7-4272-dac5-b0975342c32d"
+      },
+      "source": [
+        "GRF_params=jnp.array([GRF_LogAmp,GRF_beta])\n",
+        "get_jaxified_GRF_pure(GRF_params,GRF_seed)"
+      ],
+      "execution_count": 59,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([[-0.01243255, -0.00829889,  0.00402387, ..., -0.00904885,\n",
+              "              -0.00604214, -0.00302176],\n",
+              "             [-0.00226499, -0.01453809, -0.0219767 , ...,  0.01113688,\n",
+              "               0.00434794,  0.00886271],\n",
+              "             [ 0.00602436, -0.01029537, -0.01696046, ...,  0.01601606,\n",
+              "               0.01204917,  0.00664493],\n",
+              "             ...,\n",
+              "             [ 0.01468725,  0.00566183,  0.01739841, ..., -0.0066037 ,\n",
+              "               0.00138568,  0.01062642],\n",
+              "             [-0.00426157, -0.00196087, -0.01263381, ..., -0.00767667,\n",
+              "              -0.00317466, -0.00206083],\n",
+              "             [-0.01814698,  0.00783441, -0.00736378, ..., -0.01183791,\n",
+              "              -0.02245846, -0.02427405]], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 59
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "3yHBnp8jSAt9"
+      },
+      "source": [
+        "get_jaxified_GRF_pure??"
+      ],
+      "execution_count": 63,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "yWNN4_ZnOWWr"
+      },
+      "source": [
+        "#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\n",
+        "g = lambda _,GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
+        "GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])"
+      ],
+      "execution_count": 69,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 613
+        },
+        "id": "bLRekLZwQfk6",
+        "outputId": "e8d849a7-50a1-4922-df25-15c812a0a7cc"
+      },
+      "source": [
+        "GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])"
+      ],
+      "execution_count": 70,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "ConcretizationTypeError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-70-b1b57523e422>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGRFs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seeds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1287\u001b[0m   \u001b[0;31m# necessary, a second time with modified init values.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1288\u001b[0;31m   \u001b[0minit_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mrest\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_create_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1289\u001b[0m   \u001b[0mnew_init_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchanged\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_promote_weak_typed_inputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_create_jaxpr\u001b[0;34m(init)\u001b[0m\n\u001b[1;32m   1274\u001b[0m     jaxpr, consts, out_tree = _initial_style_jaxpr(\n\u001b[0;32m-> 1275\u001b[0;31m         f, in_tree, carry_avals + x_avals, \"scan\")\n\u001b[0m\u001b[1;32m   1276\u001b[0m     \u001b[0mout_tree_children\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchildren\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     76\u001b[0m   jaxpr, consts, out_tree = _initial_style_open_jaxpr(\n\u001b[0;32m---> 77\u001b[0;31m       fun, in_tree, in_avals, primitive_name)\n\u001b[0m\u001b[1;32m     78\u001b[0m   \u001b[0mclosed_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mClosedJaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert_constvars_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjaxpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-69-4b2549d67db6>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(_, GRF_seed)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m    135\u001b[0m   \u001b[0;31m#Random phase realisation in Fourier space\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 136\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    137\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m     48\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m   \u001b[0;32mif\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     50\u001b[0m     \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m__bool__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    541\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__nonzero__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_nonzero\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 542\u001b[0;31m   \u001b[0;32mdef\u001b[0m \u001b[0m__bool__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_bool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    543\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__int__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_int\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36merror\u001b[0;34m(self, arg)\u001b[0m\n\u001b[1;32m    986\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 987\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mConcretizationTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfname_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    988\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: jax._src.errors.ConcretizationTypeError: Abstract tracer value encountered where concrete value is expected: Traced<ShapedArray(int64[])>with<DynamicJaxprTrace(level=1/0)>\nThe problem arose with the `bool` function. \nWhile tracing the function <lambda> at <ipython-input-69-4b2549d67db6>:2 for scan, this concrete value was not available in Python because it depends on the value of the argument 'GRF_seed'.\n\nSee https://jax.readthedocs.io/en/latest/errors.html#jax.errors.ConcretizationTypeError\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
+            "\nThe above exception was the direct cause of the following exception:\n",
+            "\u001b[0;31mConcretizationTypeError\u001b[0m                   Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-70-b1b57523e422>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGRFs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seeds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m<ipython-input-69-4b2549d67db6>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(_, GRF_seed)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m    134\u001b[0m   \u001b[0msqrt_power_array\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_grid\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mbeta\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mmask_center\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    135\u001b[0m   \u001b[0;31m#Random phase realisation in Fourier space\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 136\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    137\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    138\u001b[0m   \u001b[0;31m#Create fourier image with random phases\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m     47\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     48\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m   \u001b[0;32mif\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     50\u001b[0m     \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mConcretizationTypeError\u001b[0m: Abstract tracer value encountered where concrete value is expected: Traced<ShapedArray(int64[])>with<DynamicJaxprTrace(level=1/0)>\nThe problem arose with the `bool` function. \nWhile tracing the function <lambda> at <ipython-input-69-4b2549d67db6>:2 for scan, this concrete value was not available in Python because it depends on the value of the argument 'GRF_seed'.\n\nSee https://jax.readthedocs.io/en/latest/errors.html#jax.errors.ConcretizationTypeError"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hEhaBSiYRNzV",
+        "outputId": "d65c6609-843d-408d-eae0-80ad9e8406cc"
+      },
+      "source": [
+        "GRFs"
+      ],
+      "execution_count": 55,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeviceArray([[[2., 2., 2., ..., 2., 2., 2.],\n",
+              "              [2., 2., 2., ..., 2., 2., 2.],\n",
+              "              [2., 2., 2., ..., 2., 2., 2.],\n",
+              "              ...,\n",
+              "              [2., 2., 2., ..., 2., 2., 2.],\n",
+              "              [2., 2., 2., ..., 2., 2., 2.],\n",
+              "              [2., 2., 2., ..., 2., 2., 2.]],\n",
+              "\n",
+              "             [[3., 3., 3., ..., 3., 3., 3.],\n",
+              "              [3., 3., 3., ..., 3., 3., 3.],\n",
+              "              [3., 3., 3., ..., 3., 3., 3.],\n",
+              "              ...,\n",
+              "              [3., 3., 3., ..., 3., 3., 3.],\n",
+              "              [3., 3., 3., ..., 3., 3., 3.],\n",
+              "              [3., 3., 3., ..., 3., 3., 3.]],\n",
+              "\n",
+              "             [[4., 4., 4., ..., 4., 4., 4.],\n",
+              "              [4., 4., 4., ..., 4., 4., 4.],\n",
+              "              [4., 4., 4., ..., 4., 4., 4.],\n",
+              "              ...,\n",
+              "              [4., 4., 4., ..., 4., 4., 4.],\n",
+              "              [4., 4., 4., ..., 4., 4., 4.],\n",
+              "              [4., 4., 4., ..., 4., 4., 4.]],\n",
+              "\n",
+              "             ...,\n",
+              "\n",
+              "             [[7., 7., 7., ..., 7., 7., 7.],\n",
+              "              [7., 7., 7., ..., 7., 7., 7.],\n",
+              "              [7., 7., 7., ..., 7., 7., 7.],\n",
+              "              ...,\n",
+              "              [7., 7., 7., ..., 7., 7., 7.],\n",
+              "              [7., 7., 7., ..., 7., 7., 7.],\n",
+              "              [7., 7., 7., ..., 7., 7., 7.]],\n",
+              "\n",
+              "             [[8., 8., 8., ..., 8., 8., 8.],\n",
+              "              [8., 8., 8., ..., 8., 8., 8.],\n",
+              "              [8., 8., 8., ..., 8., 8., 8.],\n",
+              "              ...,\n",
+              "              [8., 8., 8., ..., 8., 8., 8.],\n",
+              "              [8., 8., 8., ..., 8., 8., 8.],\n",
+              "              [8., 8., 8., ..., 8., 8., 8.]],\n",
+              "\n",
+              "             [[9., 9., 9., ..., 9., 9., 9.],\n",
+              "              [9., 9., 9., ..., 9., 9., 9.],\n",
+              "              [9., 9., 9., ..., 9., 9., 9.],\n",
+              "              ...,\n",
+              "              [9., 9., 9., ..., 9., 9., 9.],\n",
+              "              [9., 9., 9., ..., 9., 9., 9.],\n",
+              "              [9., 9., 9., ..., 9., 9., 9.]]], dtype=float64)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 55
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "fKrMW5BKOrur"
+      },
+      "source": [
+        "GRF_seeds=np.arange(2,10)"
+      ],
+      "execution_count": 22,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "31bkJ2eTPLnD",
+        "outputId": "32f499df-70cb-4baf-821d-cb4035fcbffd"
+      },
+      "source": [
+        "GRF_seeds"
+      ],
+      "execution_count": 26,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([2, 3, 4, 5, 6, 7, 8, 9])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 26
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bYNbPnvoP4Uv"
+      },
+      "source": [
+        "def map(f, xs):\n",
+        "    return np.stack([f(x) for x in xs])"
+      ],
+      "execution_count": 34,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ABovifh1P5wV",
+        "outputId": "ce70da44-9a57-4973-e084-3dc4acc11577"
+      },
+      "source": [
+        "map(g,GRF_seeds)"
+      ],
+      "execution_count": 36,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([[[-0.00570171, -0.00129161,  0.0058245 , ..., -0.00757102,\n",
+              "         -0.00243726, -0.01649447],\n",
+              "        [ 0.00493164, -0.00220677, -0.00262641, ..., -0.01041471,\n",
+              "         -0.0095766 , -0.01066423],\n",
+              "        [-0.00321968, -0.01664846, -0.00271096, ..., -0.0238819 ,\n",
+              "         -0.00081087, -0.00673764],\n",
+              "        ...,\n",
+              "        [-0.00682896,  0.00358378,  0.00185109, ..., -0.00034693,\n",
+              "         -0.0172854 , -0.01211973],\n",
+              "        [ 0.00313957,  0.00894859,  0.00696749, ...,  0.00331316,\n",
+              "         -0.01668601, -0.00939343],\n",
+              "        [-0.01528318,  0.00801151,  0.00499301, ...,  0.00171082,\n",
+              "          0.00492917, -0.01536378]],\n",
+              "\n",
+              "       [[ 0.00245054, -0.00181478,  0.00855211, ..., -0.00014682,\n",
+              "          0.00316356,  0.0037077 ],\n",
+              "        [-0.01105917,  0.00272392,  0.00126246, ..., -0.00935565,\n",
+              "          0.00261621, -0.00807424],\n",
+              "        [ 0.00189058,  0.01246546, -0.00043618, ..., -0.00888243,\n",
+              "         -0.00943269, -0.01652462],\n",
+              "        ...,\n",
+              "        [ 0.00740169,  0.00177444,  0.00654389, ...,  0.00113258,\n",
+              "          0.0074417 ,  0.02392809],\n",
+              "        [-0.00511541,  0.00459735,  0.01046327, ...,  0.01150066,\n",
+              "         -0.00035693,  0.01335217],\n",
+              "        [-0.00960982, -0.00622419,  0.00907952, ...,  0.00919878,\n",
+              "          0.01221109,  0.00588644]],\n",
+              "\n",
+              "       [[-0.0139905 , -0.01638946, -0.0172895 , ..., -0.02114541,\n",
+              "         -0.02840538, -0.01410159],\n",
+              "        [-0.01689089, -0.00574568, -0.00956084, ..., -0.00669177,\n",
+              "         -0.01476772, -0.01590232],\n",
+              "        [-0.01420469, -0.00935511, -0.01111654, ..., -0.00626801,\n",
+              "         -0.0099091 , -0.01716254],\n",
+              "        ...,\n",
+              "        [-0.0137148 , -0.00494926, -0.0020264 , ..., -0.01500677,\n",
+              "         -0.01389189, -0.01912288],\n",
+              "        [-0.0272826 , -0.00955068, -0.00430711, ..., -0.02163854,\n",
+              "         -0.01288849, -0.01248661],\n",
+              "        [-0.01883318, -0.02027143, -0.00810125, ..., -0.01875949,\n",
+              "         -0.02265133, -0.01283164]],\n",
+              "\n",
+              "       ...,\n",
+              "\n",
+              "       [[-0.01230228, -0.01800172, -0.02579664, ...,  0.0073786 ,\n",
+              "          0.00191748, -0.00412699],\n",
+              "        [-0.02118216, -0.01941043, -0.02257236, ..., -0.0082184 ,\n",
+              "         -0.00647608, -0.00765698],\n",
+              "        [-0.02644685, -0.01421645, -0.02074588, ..., -0.01580186,\n",
+              "         -0.00524229, -0.00874206],\n",
+              "        ...,\n",
+              "        [-0.0135957 , -0.01621485, -0.01872369, ...,  0.00644837,\n",
+              "         -0.01356566, -0.01610557],\n",
+              "        [-0.01129862, -0.00167056, -0.01800664, ..., -0.00673788,\n",
+              "         -0.00021035, -0.0225168 ],\n",
+              "        [-0.01089003, -0.00209198, -0.01326153, ..., -0.0069217 ,\n",
+              "          0.00692525, -0.0028887 ]],\n",
+              "\n",
+              "       [[ 0.01655477,  0.0056518 ,  0.00598932, ...,  0.01250736,\n",
+              "          0.02933828,  0.03217609],\n",
+              "        [ 0.00895991,  0.01713715,  0.0227057 , ...,  0.02304084,\n",
+              "          0.01878312,  0.01828753],\n",
+              "        [ 0.02908461,  0.03373585,  0.01912583, ...,  0.01770112,\n",
+              "          0.024731  ,  0.02216083],\n",
+              "        ...,\n",
+              "        [ 0.0212948 ,  0.01322786,  0.01144615, ...,  0.001536  ,\n",
+              "          0.00905991,  0.01523457],\n",
+              "        [ 0.01169935,  0.00222409,  0.02501316, ...,  0.00011715,\n",
+              "          0.00060522,  0.00872047],\n",
+              "        [ 0.00594872,  0.00560278,  0.01655162, ...,  0.01192272,\n",
+              "          0.01623821,  0.00911491]],\n",
+              "\n",
+              "       [[ 0.01839963,  0.01470064,  0.0126376 , ..., -0.00092679,\n",
+              "          0.00714594,  0.0190327 ],\n",
+              "        [ 0.00196516, -0.00613721,  0.00104802, ...,  0.00682581,\n",
+              "         -0.00405272,  0.0004448 ],\n",
+              "        [-0.01414344, -0.00324376,  0.00613208, ...,  0.0101815 ,\n",
+              "         -0.00572056, -0.00116558],\n",
+              "        ...,\n",
+              "        [-0.01421333, -0.00510635,  0.004092  , ..., -0.00255698,\n",
+              "         -0.00059953, -0.00947415],\n",
+              "        [ 0.00629259,  0.0113965 ,  0.00846697, ...,  0.01365204,\n",
+              "          0.00871522,  0.00343058],\n",
+              "        [ 0.01040981,  0.02313104,  0.01368947, ...,  0.00845253,\n",
+              "          0.00874118,  0.02016828]]])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 36
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 596
+        },
+        "id": "5lMpvhDdOck0",
+        "outputId": "a9c2d00f-7bff-4052-cc89-e51a3bf69412"
+      },
+      "source": [
+        "jax.lax.scan(test, 0, tuple([1,2,3]))[1]"
+      ],
+      "execution_count": 33,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "ValueError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1227\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1228\u001b[0;31m     \u001b[0mlengths\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxs_flat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1229\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m   1227\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1228\u001b[0;31m     \u001b[0mlengths\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxs_flat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1229\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute 'shape'",
+            "\nThe above exception was the direct cause of the following exception:\n",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-33-28a14e864087>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1232\u001b[0m       msg.format(', '.join(str(x) for x in xs_flat\n\u001b[0;32m-> 1233\u001b[0;31m                            if not hasattr(x, 'shape')))) from err\n\u001b[0m\u001b[1;32m   1234\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: ValueError: scan got value with no leading axis to scan over: 1, 2, 3.\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
+            "\nThe above exception was the direct cause of the following exception:\n",
+            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-33-28a14e864087>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1231\u001b[0m     raise ValueError(\n\u001b[1;32m   1232\u001b[0m       msg.format(', '.join(str(x) for x in xs_flat\n\u001b[0;32m-> 1233\u001b[0;31m                            if not hasattr(x, 'shape')))) from err\n\u001b[0m\u001b[1;32m   1234\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1235\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mlength\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mValueError\u001b[0m: scan got value with no leading axis to scan over: 1, 2, 3."
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Jd0-NY0vMyno"
+      },
+      "source": [
+        "q=lambda GRF_seed: get_jaxified_GRF_pure([GRF_LogAmp,GRF_beta],GRF_seed)"
+      ],
+      "execution_count": 17,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "TYp4CcLbKWmb"
+      },
+      "source": [
+        "q_mapped=jax.vmap(get_jaxified_GRF_pure,in_axes=(0,None,),out_axes=(None,))"
+      ],
+      "execution_count": 18,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 596
+        },
+        "id": "VBhzVnQYNPlO",
+        "outputId": "05deaa08-2b95-454f-b7b0-e8c13cdba6d7"
+      },
+      "source": [
+        "q_mapped([2,3])"
+      ],
+      "execution_count": 20,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "ValueError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_mapped_axis_size\u001b[0;34m(tree, vals, dims, name, kws)\u001b[0m\n\u001b[1;32m   1305\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1306\u001b[0;31m     \u001b[0msize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmapped_axis_sizes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1307\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0msize\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 1, got 0)",
+            "\nThe above exception was the direct cause of the following exception:\n",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-20-8bd21f1e5033>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mq_mapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mbatched_fun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1282\u001b[0m     \u001b[0min_axes_flat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_axes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"vmap in_axes\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0min_axes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1283\u001b[0;31m     \u001b[0maxis_size\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_mapped_axis_size\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_axes_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"vmap\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1284\u001b[0m     out_flat = batching.batch(\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_mapped_axis_size\u001b[0;34m(tree, vals, dims, name, kws)\u001b[0m\n\u001b[1;32m   1309\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mmapped_axis_sizes\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1310\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"{name} must have at least one non-None value in in_axes\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1311\u001b[0m     \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{name} got inconsistent sizes for array axes to be mapped:\\n\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"{}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: ValueError: vmap must have at least one non-None value in in_axes\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
+            "\nThe above exception was the direct cause of the following exception:\n",
+            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-20-8bd21f1e5033>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mq_mapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_mapped_axis_size\u001b[0;34m(tree, vals, dims, name, kws)\u001b[0m\n\u001b[1;32m   1308\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1309\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mmapped_axis_sizes\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1310\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"{name} must have at least one non-None value in in_axes\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1311\u001b[0m     \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{name} got inconsistent sizes for array axes to be mapped:\\n\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"{}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1312\u001b[0m     \u001b[0;31m# we switch the error message based on whether args is a tuple of arrays,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mValueError\u001b[0m: vmap must have at least one non-None value in in_axes"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Bx5wCk5VK8He",
+        "outputId": "d3239e00-3980-4f7b-cf5e-3635fd9db800"
+      },
+      "source": [
+        "unperturbed_image.shape"
+      ],
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(100, 100)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 16
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "BXbopWnRJ2g1"
+      },
+      "source": [
+        "\n",
+        "def GRF_Loss_phase_averaging(GRF_params,GRF_seed_array,unperturbed_image,\n",
+        "             get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
+        "             compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
+        "\n",
+        "  (npix,_)=unperturbed_image.shape\n",
+        "  phase_number=len(GRF_seed_array)\n",
+        "  GRFs=jnp.ones((phase_number,npix,npix))\n",
+        "\n",
+        "  \n",
+        "\n",
+        "  GRF=get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
+        "\n",
+        "  simulated_image=simulate_perturbed_image_pure(GRF)\n",
+        "\n",
+        "  resid=simulated_image-unperturbed_image\n",
+        "  resid_spectrum=compute_radial_spectrum_pure(resid)\n",
+        "\n",
+        "  return Spectra_Loss_pure(resid_spectrum)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qoEHwfDQJvRZ"
+      },
+      "source": [
+        "## MAE loss function"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "lkzMiBL4WFpB"
+      },
+      "source": [
+        "Spectra_Loss_pure=purify_function(Spectra_Loss_MAE,resid_true_spectrum)"
+      ],
+      "execution_count": 15,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "9ndZ7s2XJuAd"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file

From c2eb9c2c683f04b551fb78ccc06681b398a11f17 Mon Sep 17 00:00:00 2001
From: Egor Danilov <egor.danilov@epfl.ch>
Date: Mon, 23 Aug 2021 20:10:44 +0200
Subject: [PATCH 2/4] =?UTF-8?q?Revert=20"=D0=A1=D0=BE=D0=B7=D0=B4=D0=B0?=
 =?UTF-8?q?=D0=BD=D0=BE=20=D1=81=20=D0=BF=D0=BE=D0=BC=D0=BE=D1=89=D1=8C?=
 =?UTF-8?q?=D1=8E=20Colaboratory"?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This reverts commit 98c811e1cf8c7e72c29f2379aa06ceb42d1b9eb4.
---
 .../GRF_fitting_imperfect_case.ipynb          | 6263 -----------------
 1 file changed, 6263 deletions(-)
 delete mode 100644 GRF_notebooks/GRF_fitting_imperfect_case.ipynb

diff --git a/GRF_notebooks/GRF_fitting_imperfect_case.ipynb b/GRF_notebooks/GRF_fitting_imperfect_case.ipynb
deleted file mode 100644
index c7caba6..0000000
--- a/GRF_notebooks/GRF_fitting_imperfect_case.ipynb
+++ /dev/null
@@ -1,6263 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "name": "GRF_fitting_imperfect_case.ipynb",
-      "provenance": [],
-      "collapsed_sections": [
-        "CV4BAYge0GFU",
-        "yKr5aWbhQD_8",
-        "KhzVyjGVSa7y",
-        "0jNY6Ef4Qw23",
-        "BRk6ZMNZSdDi",
-        "UTBJhBM9SjFS",
-        "35uYn8NxCw3O",
-        "NHArYiagUpEY",
-        "Vpn26QPlUYFC",
-        "k_dhaQmgp4G_",
-        "uf5_Pykzi_6R",
-        "wQJOF7jjU-rS",
-        "lF3UWo-yVMwG",
-        "pOpk6BLaVgvD"
-      ],
-      "authorship_tag": "ABX9TyPmcmE1Bio+LusTGSE4HVyP",
-      "include_colab_link": true
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "name": "python3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "view-in-github",
-        "colab_type": "text"
-      },
-      "source": [
-        "<a href=\"https://colab.research.google.com/github/austinpeel/jax-strong-lensing/blob/dev-aym/GRF_notebooks/GRF_fitting_imperfect_case.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "7fsjC3Frkdkb",
-        "outputId": "96fb88fd-7bf7-43f8-97b0-32ef457abaec"
-      },
-      "source": [
-        "from google.colab import drive\n",
-        "drive.mount('/content/drive')\n",
-        "\n",
-        "Folder='/content/drive/My Drive/Jax_Strong_Lensing/'\n",
-        "\n",
-        "import sys\n",
-        "sys.path.append(Folder+'/Modules')\n",
-        "_=!python drive/My\\ Drive/Jax_Strong_Lensing/Modules/My_repo/setup.py install"
-      ],
-      "execution_count": 1,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "Mounted at /content/drive\n"
-          ],
-          "name": "stdout"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "25RzDF9-kuYt"
-      },
-      "source": [
-        "# Plotting\n",
-        "import matplotlib.pyplot as plt\n",
-        "import matplotlib as mpl\n",
-        "import seaborn as sns\n",
-        "%matplotlib inline\n",
-        "\n",
-        "\n",
-        "# Basic imports\n",
-        "import numpy as np\n",
-        "from copy import deepcopy\n",
-        "import pandas as pd\n",
-        "from tqdm import tqdm\n",
-        "import math\n",
-        "\n",
-        "#JAX\n",
-        "import jax\n",
-        "import jax.numpy as jnp\n",
-        "from jax.config import config\n",
-        "config.update(\"jax_enable_x64\", True)\n",
-        "config.update(\"jax_debug_nans\", True)\n",
-        "\n",
-        "#Optimizer\n",
-        "from jax.scipy.optimize import minimize as jax_minimize\n",
-        "from scipy.optimize import minimize as scipy_minimize\n",
-        "\n",
-        "#Jaxtronomy\n",
-        "from jaxtronomy.Coordinates.pixel_grid import PixelGrid\n",
-        "from jaxtronomy.Instrument.psf import PSF\n",
-        "from jaxtronomy.Instrument.noise import Noise\n",
-        "from jaxtronomy.LightModel.light_model import LightModel\n",
-        "from jaxtronomy.LensModel.lens_model import LensModel\n",
-        "from jaxtronomy.LensImage.lens_image import LensImage\n",
-        "from jaxtronomy.Parameters.parameters import Parameters\n",
-        "\n",
-        "\n",
-        "\n",
-        "#Jaxified GRF generator\n",
-        "from jaxtronomy.GaussianRandomField.PowerBox_jaxified import get_jaxified_GRF\n",
-        "import jaxtronomy.GaussianRandomField.PowerBox_jaxified as PowerBox_jax\n",
-        "\n",
-        "#Utils for GRF fitting\n",
-        "from jaxtronomy.GaussianRandomField.GRF_fitting import purify_function,get_parameters,get_lens_models,simulate_perturbed_image,simulate_smooth_image,model_loss_function\n",
-        "#Utils for computing axially averaged spectrum\n",
-        "from jaxtronomy.GaussianRandomField.GRF_fitting import Radial_profile,compute_radial_spectrum\n",
-        "#Utils for fitting the GRF\n",
-        "from jaxtronomy.GaussianRandomField.GRF_fitting import GRF_Loss,Spectra_Loss_MSE,Spectra_Loss_MAE\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# Universal font size\n",
-        "FS = 18"
-      ],
-      "execution_count": 312,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "CV4BAYge0GFU"
-      },
-      "source": [
-        "# Theory"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "krwXUDEG0Cdu"
-      },
-      "source": [
-        "Assume that we have GRF perturbed strong lensing event. First, we want to model it without GRF perturbations and consider the residuals.\n",
-        "\n",
-        "## Data\n",
-        "\n",
-        "simulation: $\\psi(\\vec{p}_{0})+\\delta \\psi(A_{0},\\beta_{0},\\phi_{0})$  \n",
-        "model 1: $\\psi(\\vec{p_0})$  \n",
-        "$res_{0}=Im(\\delta \\psi(A_{0},\\beta_{0},\\phi_{0})+\\psi(\\vec{p}_{0})-\\psi(\\vec{p_1}))$\n",
-        "\n",
-        ",where $\\vec{p}$ is a set of source light and unperturbed lens mass parameters and $A_{0},\\beta_{0},\\phi_{0}$ are correpsondingly amplitude,power slope and phase realisation of GRF power spectrum. Index 0 would refer to true values or zeroth aproximation.\n",
-        "\n",
-        "## Model\n",
-        "\n",
-        "mock: $\\psi(\\vec{p}_{0})+\\delta \\psi(A^{i},\\beta^{j},\\phi_{0})$  \n",
-        "model 2: $\\psi(\\vec{p_0})$  \n",
-        "$res^{i,j}=Im(\\delta \\psi(A^{i},\\beta^{j},\\phi^{m})+\\psi(\\vec{p}_{1})-\\psi(\\vec{p_2}))$\n",
-        "\n",
-        ",where we assume that we know the exact lens-source parameters \\vec{p_0}, and exact GRF phase \\phi_{0}\n",
-        "\n",
-        "## Loss\n",
-        "$ PS\\{ res_{0} \\}=|FFT\\{res_{0}*mask\\_ring\\}|^{2} $  \n",
-        "$\\mathcal{L}^{ij}=|| \\ PS\\{res_{0}\\} - PS\\{res^{i,j}\\} \\ ||$\n",
-        "\n",
-        "## Pipeline\n",
-        "\n",
-        "Given lens args $\\vec{p}_{0}$ and GRF's phase $\\phi_{0}$,\n",
-        "\n",
-        "simulate data\n",
-        "\n",
-        "logA,beta -> GRF potential -> perturbed image -> residuals with unperturbed image -> power spectrum of residuals\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "yKr5aWbhQD_8"
-      },
-      "source": [
-        "# Lensing setup"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "ELPduukaRJRL"
-      },
-      "source": [
-        "#GRF true parameters\n",
-        "GRF_LogAmp=-7.\n",
-        "GRF_beta=2.\n",
-        "GRF_seed=1"
-      ],
-      "execution_count": 3,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "KhzVyjGVSa7y"
-      },
-      "source": [
-        "## Data grids"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "ADXViDq1SXpM"
-      },
-      "source": [
-        "npix = 100\n",
-        "pix_scl = 0.08  # arcsec / pixel\n",
-        "half_size = npix * pix_scl / 2\n",
-        "ra_at_xy_0 = dec_at_xy_0 = -half_size + pix_scl / 2\n",
-        "transform_pix2angle = pix_scl * np.eye(2)\n",
-        "kwargs_pixel = {'nx': npix, 'ny': npix,\n",
-        "                'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0,\n",
-        "                'transform_pix2angle': transform_pix2angle}\n",
-        "pixel_grid = PixelGrid(**kwargs_pixel)\n",
-        "xgrid, ygrid = pixel_grid.pixel_coordinates\n",
-        "x_coords = xgrid[0, :]\n",
-        "y_coords = ygrid[:, 0]"
-      ],
-      "execution_count": 4,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "0jNY6Ef4Qw23"
-      },
-      "source": [
-        "## Models"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "RvkYufBtQ35J",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "5a2f1375-cf62-41c2-b54d-b66559d7a7cb"
-      },
-      "source": [
-        "#Source light\n",
-        "source_light_model_list = ['SERSIC_ELLIPSE']\n",
-        "source_light_model = LightModel(source_light_model_list)\n",
-        "kwargs_source_light = [{'amp': 10.0, 'R_sersic': 1.2, 'n_sersic': 1.5, 'center_x': 0.4, 'center_y': 0.15,'e1':0.07,'e2':-0.1}]\n",
-        "\n",
-        "#Lens mass\n",
-        "lens_mass_model_list = ['SIE', 'SHEAR','PIXELATED']\n",
-        "lens_mass_model = LensModel(lens_mass_model_list)\n",
-        "GRF_realisation=get_jaxified_GRF([GRF_LogAmp,GRF_beta],GRF_seed,npix,pix_scl)\n",
-        "kwargs_lens_mass = [{'theta_E': 1.6, 'e1': 0.15, 'e2': -0.04, 'center_x': 0.0, 'center_y': 0.0},\\\n",
-        "                    {'gamma1': -0.01, 'gamma2': 0.03, 'ra_0': 0.0, 'dec_0': 0.0},\\\n",
-        "                    {'x_coords': x_coords, 'y_coords': y_coords, 'psi_grid': GRF_realisation}]\n",
-        "\n",
-        "#Lens light\n",
-        "lens_light_model_list = []\n",
-        "lens_light_model = LightModel(lens_light_model_list)\n",
-        "kwargs_lens_light = [{}]"
-      ],
-      "execution_count": 5,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
-          ],
-          "name": "stderr"
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "BRk6ZMNZSdDi"
-      },
-      "source": [
-        "## Source light model"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "5XKVQZMmSb6F"
-      },
-      "source": [
-        "source_light_model_list = ['SERSIC_ELLIPSE']\n",
-        "source_light_model = LightModel(source_light_model_list)\n",
-        "kwargs_source_light = [{'amp': 10.0, 'R_sersic': 1.2, 'n_sersic': 1.5, 'center_x': 0.4, 'center_y': 0.15,'e1':0.07,'e2':-0.1}]"
-      ],
-      "execution_count": 6,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "UTBJhBM9SjFS"
-      },
-      "source": [
-        "## Lens model (SIE + external shear)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "EBPLp82dSg5s"
-      },
-      "source": [
-        "# Lens mass\n",
-        "lens_mass_model_list = ['SIE', 'SHEAR','PIXELATED']\n",
-        "lens_mass_model = LensModel(lens_mass_model_list)\n",
-        "\n",
-        "GRF_realisation=get_jaxified_GRF([GRF_LogAmp,GRF_beta],GRF_seed,npix,pix_scl)\n",
-        "kwargs_lens_mass = [{'theta_E': 1.6, 'e1': 0.15, 'e2': -0.04, 'center_x': 0.0, 'center_y': 0.0},\\\n",
-        "                    {'gamma1': -0.01, 'gamma2': 0.03, 'ra_0': 0.0, 'dec_0': 0.0},\\\n",
-        "                    {'x_coords': x_coords, 'y_coords': y_coords, 'psi_grid': GRF_realisation}]\n",
-        "\n",
-        "# Lens light\n",
-        "lens_light_model_list = []\n",
-        "lens_light_model = LightModel(lens_light_model_list)\n",
-        "kwargs_lens_light = [{}]\n",
-        "\n",
-        "#Combined kwargs smooth\n",
-        "kwargs_data = {'kwargs_lens': kwargs_lens_mass[:-1], 'kwargs_source': kwargs_source_light,'kwargs_lens_light':kwargs_lens_light}\n",
-        "\n",
-        "#Observation conditions and noise\n",
-        "kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': 0.3}\n",
-        "psf = PSF(**kwargs_psf)\n",
-        "kwargs_numerics = {'supersampling_factor': 1}\n",
-        "\n",
-        "kwargs_noise={'background_rms': np.zeros((npix, npix)), 'exposure_time': np.inf}\n",
-        "\n",
-        "#Noiseless models\n",
-        "perturbed_lens_image,smooth_lens_image=get_lens_models(pixel_grid,psf,kwargs_noise,\\\n",
-        "                                                       lens_mass_model_list,source_light_model,lens_light_model,kwargs_numerics)\n",
-        "\n",
-        "perturbed_image=simulate_perturbed_image(GRF_realisation,kwargs_data,perturbed_lens_image,x_coords,y_coords)\n",
-        "unperturbed_image=simulate_smooth_image(kwargs_data,smooth_lens_image)"
-      ],
-      "execution_count": 287,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 495
-        },
-        "id": "ichoKAx0R4IL",
-        "outputId": "81dbcafc-6f13-4d92-f218-743cd1b0a0b5"
-      },
-      "source": [
-        "# Plot\n",
-        "fig, ax = plt.subplots(1, 3, figsize=(15, 7))\n",
-        "\n",
-        "im0=ax[0].imshow(perturbed_image, origin='lower')\n",
-        "ax[0].set_title(\"Perturbed image\", fontsize=FS)\n",
-        "\n",
-        "\n",
-        "im1=ax[1].imshow(unperturbed_image, origin='lower')\n",
-        "ax[1].set_title(\"Unperturbed image\", fontsize=FS)\n",
-        "\n",
-        "\n",
-        "resid_true=perturbed_image-unperturbed_image\n",
-        "im2=ax[2].imshow(resid_true, origin='lower',cmap='seismic',norm=mpl.colors.TwoSlopeNorm(0))\n",
-        "ax[2].set_title(\"Perturbations impact\", fontsize=FS)\n",
-        "\n",
-        "for i,img in enumerate([im0,im1, im2]):\n",
-        "    ax[i].axis('off')\n",
-        "    fig.colorbar(img, ax=ax[i],orientation='horizontal')\n",
-        "\n",
-        "fig.tight_layout()"
-      ],
-      "execution_count": 288,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1080x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "35uYn8NxCw3O"
-      },
-      "source": [
-        "## Einstein ring Mask"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "C9hZLeeRCyyt"
-      },
-      "source": [
-        "rmin = 0.5\n",
-        "rmax = 3\n",
-        "radius = np.hypot(xgrid, ygrid)\n",
-        "#Mask covering Einstein ring\n",
-        "mask = ((radius >= rmin) & (radius <= rmax)).astype(bool)\n",
-        "\n",
-        "#There is no sense to consider Fourier space frequncies referring to sizes \n",
-        "#That are bigger than the thickness of the masked region\n",
-        "k_vector=np.fft.fftshift(np.fft.fftfreq(npix,pix_scl))[npix//2:]\n",
-        "#Index from which to consider frequencies\n",
-        "mask_spectral_cut_index=np.where(k_vector>1/(rmax-rmin))[0][0]\n",
-        "masked_k_vector=k_vector[mask_spectral_cut_index:]"
-      ],
-      "execution_count": 9,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 54
-        },
-        "id": "iK0gwiatS9Dd",
-        "outputId": "98635d4b-d2e6-40d9-a344-739cbc750feb"
-      },
-      "source": [
-        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 7))\n",
-        "img1 = ax1.imshow(perturbed_image*mask, origin='lower')\n",
-        "ax1.set_title(\"Perturbed image\", fontsize=FS)\n",
-        "img2 = ax2.imshow(unperturbed_image*mask, origin='lower')\n",
-        "ax2.set_title(\"Unperturbed image\", fontsize=FS)\n",
-        "for img, ax in zip((img1, img2), (ax1, ax2)):\n",
-        "    fig.colorbar(img, ax=ax,orientation='horizontal')\n",
-        "    ax.axis('off')\n",
-        "fig.suptitle('Masked images',y=1.1,fontsize=FS)\n",
-        "fig.tight_layout()"
-      ],
-      "execution_count": 10,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 720x504 with 4 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "NHArYiagUpEY"
-      },
-      "source": [
-        "## Precompile utility functions"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "o0RKVLn_UsT8"
-      },
-      "source": [
-        "# Precompile the functions with all the arguments that are static for the lensing setup\n",
-        "# So the pure functions depend only on the argument that should be traced\n",
-        "\n",
-        "#Generate GRF\n",
-        "@jax.partial(jax.jit,static_argnums=(1,))\n",
-        "def get_jaxified_GRF_pure(GRF_params,GRF_seed):\n",
-        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
-        "\n",
-        "#Simulate images for kwargs or GRF\n",
-        "simulate_perturbed_image_pure=purify_function(simulate_perturbed_image,kwargs_data,perturbed_lens_image,x_coords,y_coords)\n",
-        "simulate_smooth_image_pure=purify_function(simulate_smooth_image,smooth_lens_image)\n",
-        "\n",
-        "#Get axially averaged spectrum\n",
-        "Radial_profile_pure=purify_function(Radial_profile,(npix,npix))\n",
-        "compute_radial_spectrum_pure=purify_function(compute_radial_spectrum,Radial_profile,mask,mask_spectral_cut_index)"
-      ],
-      "execution_count": 11,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "Vpn26QPlUYFC"
-      },
-      "source": [
-        "# Target spectrum, Initial guess"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "x31Be-nCW3kN"
-      },
-      "source": [
-        "#Compute Target Power spectrum of data residuals \n",
-        "resid_true=perturbed_image-unperturbed_image\n",
-        "resid_true_spectrum=compute_radial_spectrum_pure(resid_true)"
-      ],
-      "execution_count": 12,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "ptyJj6UaW5Z1"
-      },
-      "source": [
-        "#First assumption is that power spectrum of GRF is close to power spectrum of residuals\n",
-        "#So fit the target power spectrum with a powerlaw to get an initial guess\n",
-        "\n",
-        "def Powerlaw_spectrum(params,masked_k_vector):\n",
-        "  logA,Beta=params\n",
-        "  return np.power(10,logA)*np.power(masked_k_vector,-Beta)\n",
-        "\n",
-        "def GRF_PS_loss(params,masked_k_vector,Target_spectrum):\n",
-        "  logA,Beta=params\n",
-        "  GRF_spectrum=Powerlaw_spectrum(params,masked_k_vector)\n",
-        "  MSE= np.power((Target_spectrum-GRF_spectrum)/Target_spectrum,2)\n",
-        "  return np.mean(MSE)\n",
-        "\n",
-        "#Make a fit\n",
-        "res=scipy_minimize(GRF_PS_loss,x0=[0.,1.],args=(masked_k_vector,resid_true_spectrum))\n",
-        "GRF_init_guess=np.array(res.x)"
-      ],
-      "execution_count": 13,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 320
-        },
-        "id": "KfNmCS07Uc9I",
-        "outputId": "8cee3ac2-a9d9-4d0a-8c72-220f92ef658b"
-      },
-      "source": [
-        "#Plot power spectrum and initial guess\n",
-        "plt.loglog(masked_k_vector,resid_true_spectrum,label='Target spectrum')\n",
-        "plt.loglog(masked_k_vector,Powerlaw_spectrum(GRF_init_guess,masked_k_vector),label='GRF guess')\n",
-        "plt.xlabel('Frequency,' r'$\\frac{1}{arcsec}$',fontsize=FS)\n",
-        "plt.ylabel('Power spectrum',fontsize=FS)\n",
-        "plt.title('Residuals power spectrum and GRF guess',fontsize=FS)\n",
-        "plt.legend()\n",
-        "plt.show()"
-      ],
-      "execution_count": 14,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 432x288 with 1 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "SkK_gR6WcK3D"
-      },
-      "source": [
-        "# GRF perfect case fitting"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "nfAHFVDIeHG2"
-      },
-      "source": [
-        "## MAE loss function"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "6r9BlulUcYoq"
-      },
-      "source": [
-        "#Pick spectrum loss type (weighted MSE or weighted MAE)\n",
-        "Spectra_Loss_pure=purify_function(Spectra_Loss_MAE,resid_true_spectrum)\n",
-        "GRF_Loss_args=(GRF_seed,unperturbed_image,get_jaxified_GRF_pure,simulate_perturbed_image_pure,compute_radial_spectrum_pure,Spectra_Loss_pure)\n",
-        "\n",
-        "#Precompile GRF_Loss \n",
-        "GRF_Loss_pure=purify_function(GRF_Loss,*GRF_Loss_args)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "apvqTFpAd_q_"
-      },
-      "source": [
-        "loss_func=GRF_Loss_pure\n",
-        "grad_loss_func=jax.grad(GRF_Loss_pure)\n",
-        "hess_loss_func=jax.jacfwd(jax.jacrev(loss_func))"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 332
-        },
-        "id": "SMje8iGWeQWi",
-        "outputId": "f03469b8-5d6c-4530-ad70-50b0c74a7813"
-      },
-      "source": [
-        "print('Loss: Guess={:.2f}, True:{:.2f}'.format(loss_func(GRF_init_guess),loss_func([GRF_LogAmp,GRF_beta])))\n",
-        "grad_loss=grad_loss_func(GRF_init_guess)\n",
-        "print('Grad Loss in guess: grad(logA)={:.2f}, grad(Beta)={:.2f}'.format(grad_loss[0],grad_loss[1]))\n",
-        "\n",
-        "hess_loss=hess_loss_func(GRF_init_guess)\n",
-        "sns.heatmap(np.log10(np.abs(hess_loss)),xticklabels=['logA','Beta'],yticklabels=['logA','Beta'],annot=True,fmt='.2f')\n",
-        "plt.title('Log(Abs(Hessian))')"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "Loss: Guess=207.09, True:0.00\n",
-            "Grad Loss in guess: grad(logA)=0.14, grad(Beta)=-2.91\n"
-          ],
-          "name": "stdout"
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "Text(0.5, 1.0, 'Log(Abs(Hessian))')"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 72
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 432x288 with 2 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "k_dhaQmgp4G_"
-      },
-      "source": [
-        "## Loss function and Grads"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "FgANh5bFp_Dd",
-        "outputId": "0b1ea150-8a80-4696-bae5-07b227dc3b73"
-      },
-      "source": [
-        "GRF_Amps_array=np.linspace(-7.05,-6.95,100)\n",
-        "GRF_Betas_array=np.linspace(1.5,2.5,100)\n",
-        "\n",
-        "GRF_losses_grid=np.zeros((100,100))\n",
-        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
-        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
-        "\n",
-        "for i in tqdm(range(100)):\n",
-        "  for j in range(100):\n",
-        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
-        "    GRF_Betas_grad_grid[i,j]=grad[1]"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "100%|██████████| 100/100 [08:18<00:00,  4.98s/it]\n"
-          ],
-          "name": "stderr"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 513
-        },
-        "id": "rsryFH7hqJyG",
-        "outputId": "add1b16c-c148-4a78-b4b0-d361baa09ac4"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
-        "\n",
-        "y_labels=np.round(GRF_Amps_array,9)\n",
-        "x_labels=np.round(GRF_Betas_array,2)\n",
-        "\n",
-        "num_ticks = 10\n",
-        "# the index of the position of yticks\n",
-        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
-        "# the content of labels of these yticks\n",
-        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
-        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
-        "\n",
-        "\n",
-        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "ax[1].set_yticks([])\n",
-        "ax[2].set_yticks([])\n",
-        "\n",
-        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
-        "for i in range(3):\n",
-        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
-        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
-        "  ax[i].invert_yaxis()\n",
-        "\n",
-        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
-        "fig.tight_layout()\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1080x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "hjaibQco6E4Y",
-        "outputId": "bb4907c5-6393-4378-83a7-75c8e2433112"
-      },
-      "source": [
-        "GRF_Amps_array=np.linspace(-10.,-6.,100)\n",
-        "GRF_Betas_array=np.linspace(1.,8.,100)\n",
-        "\n",
-        "GRF_losses_grid=np.zeros((100,100))\n",
-        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
-        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
-        "\n",
-        "for i in tqdm(range(100)):\n",
-        "  for j in range(100):\n",
-        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
-        "    GRF_Betas_grad_grid[i,j]=grad[1]"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "100%|██████████| 100/100 [08:18<00:00,  4.99s/it]\n"
-          ],
-          "name": "stderr"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "_zSP5ol7IXkc"
-      },
-      "source": [
-        "#Adjust history to heatmaps\n",
-        "def reindex_history(history):\n",
-        "  i_min=np.argmin(np.abs(np.nanmin(history[:,0])-GRF_Amps_array))\n",
-        "  j_min=np.argmin(np.abs(np.nanmin(history[:,1])-GRF_Betas_array))\n",
-        "\n",
-        "  history_x_labels=j_min+(history[:,1]-np.nanmin(history[:,1]))/(GRF_Betas_array[1]-GRF_Betas_array[0])\n",
-        "  history_y_labels=i_min+(history[:,0]-np.nanmin(history[:,0]))/(GRF_Amps_array[1]-GRF_Amps_array[0])\n",
-        "  return history_x_labels,history_y_labels"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Q9PPuCJR9t3i"
-      },
-      "source": [
-        "history_trust_constr_hess=np.load(Folder+'/Images/history_trust-constr_hess.npy',allow_pickle=True)\n",
-        "\n",
-        "history_hess_x_labels,history_hess_y_labels=reindex_history(np.load(Folder+'/Images/history_trust-constr_hess.npy',allow_pickle=True))\n",
-        "history_jac_loose_x_labels,history_jac_loose_y_labels=reindex_history(np.load(Folder+'/Images/history_trust-constr_jac_loose_bounds.npy',allow_pickle=True))\n",
-        "history_jac_tight_x_labels,history_jac_tight_y_labels=reindex_history(np.load(Folder+'/Images/history_trust-constr_jac_tight_bounds.npy',allow_pickle=True))"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 513
-        },
-        "id": "O-fhPpXT6Ny8",
-        "outputId": "4ecbcd3f-0653-474c-d9c3-1feb8064c670"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
-        "\n",
-        "y_labels=np.round(GRF_Amps_array,9)\n",
-        "x_labels=np.round(GRF_Betas_array,2)\n",
-        "\n",
-        "num_ticks = 10\n",
-        "# the index of the position of yticks\n",
-        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
-        "# the content of labels of these yticks\n",
-        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
-        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
-        "\n",
-        "#Loss\n",
-        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "#Fitting\n",
-        "sns.lineplot(ax=ax[0],x=history_hess_x_labels,y=history_hess_y_labels,label='Hessian fitting',color='C0')\n",
-        "#ax[0].lines[0].set_linestyle((0, (1, 4)))\n",
-        "sns.lineplot(ax=ax[0],x=history_jac_loose_x_labels,y=history_jac_loose_y_labels,label='Jac loose bounds fitting',color='black')\n",
-        "#ax[0].lines[1].set_linestyle((0, (3, 5, 1, 5)))\n",
-        "sns.lineplot(ax=ax[0],x=history_jac_tight_x_labels,y=history_jac_tight_y_labels,label='Jac tight bounds fitting',color='C2')\n",
-        "#ax[0].lines[2].set_linestyle((0, (5, 5)))\n",
-        "ax[0].legend(loc='lower left')\n",
-        "\n",
-        "#Grad Amp\n",
-        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "#Grad Beta\n",
-        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "ax[1].set_yticks([])\n",
-        "ax[2].set_yticks([])\n",
-        "\n",
-        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
-        "for i in range(3):\n",
-        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
-        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
-        "  ax[i].invert_yaxis()\n",
-        "  \n",
-        "\n",
-        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
-        "fig.tight_layout()\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1080x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "uf5_Pykzi_6R"
-      },
-      "source": [
-        "## Optimize"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "RQm7dJme6ANL"
-      },
-      "source": [
-        "### with hessian"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 1000
-        },
-        "id": "Lo7OP0I7jE50",
-        "outputId": "8d68a2aa-dfc8-4ec2-83da-a0f0c30fac8c"
-      },
-      "source": [
-        "Nfeval = 1\n",
-        "history=np.zeros((0,2))\n",
-        "init_guess=np.array([-1.,GRF_beta])\n",
-        "bounds=((-10., -0.), (1., 10.0))\n",
-        "\n",
-        "def callbackF(Xi,optimizer):\n",
-        "    global Nfeval\n",
-        "    global history\n",
-        "    loss=loss_func(Xi)\n",
-        "    grad=grad_loss_func(Xi)\n",
-        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
-        "    Nfeval += 1\n",
-        "    history=np.append(history,[Xi],axis=0)\n",
-        "\n",
-        "\n",
-        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,hess=hess_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "   1   -0.035741    4.949092    207.091483    0.137991 -2.910105\n",
-            "   2   -0.856198    4.945717    206.986700    0.183442 -0.644057\n",
-            "   3   -5.868589    4.822722    34.358590    87.559386  42.138639\n",
-            "   4   -5.943401    4.010312    11.876488    28.462279  10.283309\n",
-            "   5   -6.262875    3.900018    4.869780    12.916308  3.930109\n",
-            "   6   -6.794334    4.062581    1.249628    3.842801  1.479443\n",
-            "   7   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
-            "   8   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
-            "   9   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
-            "  10   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
-            "  11   -7.160458    3.924507    0.387789    0.636191  0.350079\n",
-            "  12   -7.207761    3.898954    0.360317    0.164798  0.175580\n",
-            "  13   -7.207761    3.898954    0.360317    0.164798  0.175580\n",
-            "  14   -7.221226    3.884089    0.357859   -0.349431 -0.001718\n",
-            "  15   -7.221226    3.884089    0.357859   -0.349431 -0.001718\n",
-            "  16   -7.221226    3.884089    0.357859   -0.349431 -0.001718\n",
-            "  17   -7.211221    3.884629    0.357271    0.157227  0.171996\n",
-            "  18   -7.217842    3.877100    0.356681   -0.351994 -0.000985\n",
-            "  19   -7.207834    3.877620    0.356594    0.155828  0.172378\n",
-            "  20   -7.214412    3.870055    0.355474   -0.354625 -0.000236\n",
-            "  21   -7.214412    3.870055    0.355474   -0.354625 -0.000236\n",
-            "  22   -7.214412    3.870055    0.355474   -0.354625 -0.000236\n",
-            "  23   -7.209407    3.870304    0.355128    0.051017  0.136020\n",
-            "  24   -7.210611    3.865440    0.354555   -0.052266  0.102385\n",
-            "  25   -7.210611    3.865440    0.354555   -0.052266  0.102385\n",
-            "  26   -7.210611    3.865440    0.354555   -0.052266  0.102385\n",
-            "  27   -6.984057    3.471154    0.343855    0.826480  0.394790\n",
-            "  28   -6.984057    3.471154    0.343855    0.826480  0.394790\n",
-            "  29   -7.129605    3.405498    0.338805   -1.410410 -0.162208\n",
-            "  30   -6.971061    3.423410    0.335638    0.801107  0.392919\n",
-            "  31   -7.116065    3.356675    0.326977   -1.440864 -0.143728\n",
-            "  32   -6.957190    3.372225    0.327284    0.984568  0.394245\n",
-            "  33   -7.106979    3.316397    0.319322   -1.559944 -0.155122\n",
-            "  34   -7.106979    3.316397    0.319322   -1.559944 -0.155122\n",
-            "  35   -7.027512    3.324096    0.270569    0.141178  0.249814\n",
-            "  36   -7.027512    3.324096    0.270569    0.141178  0.249814\n",
-            "  37   -7.055146    3.277961    0.262186   -0.284263  0.153181\n",
-            "  38   -7.055146    3.277961    0.262186   -0.284263  0.153181\n",
-            "  39   -7.005833    3.254395    0.256244    0.399160  0.300427\n",
-            "  40   -7.005833    3.254395    0.256244    0.399160  0.300427\n",
-            "  41   -7.043987    3.227996    0.250892   -0.320593  0.164473\n",
-            "  42   -7.001533    3.208769    0.244381    0.287187  0.272370\n",
-            "  43   -7.001533    3.208769    0.244381    0.287187  0.272370\n",
-            "  44   -7.030741    3.183452    0.238945   -0.259249  0.195838\n",
-            "  45   -7.030741    3.183452    0.238945   -0.259249  0.195838\n",
-            "  46   -6.998408    3.162001    0.233696    0.387363  0.223868\n",
-            "  47   -6.998408    3.162001    0.233696    0.387363  0.223868\n",
-            "  48   -7.021224    3.150149    0.229898   -0.155247  0.211181\n",
-            "  49   -6.988518    3.111610    0.227155    0.410162  0.206936\n",
-            "  50   -6.988518    3.111610    0.227155    0.410162  0.206936\n",
-            "  51   -7.012022    3.101088    0.220559    0.014241  0.148117\n",
-            "  52   -7.016014    3.051789    0.214564   -0.194352  0.115170\n",
-            "  53   -7.016014    3.051789    0.214564   -0.194352  0.115170\n",
-            "  54   -7.016014    3.051789    0.214564   -0.194352  0.115170\n",
-            "  55   -6.994602    3.041258    0.212216    0.088964  0.169036\n",
-            "  56   -7.018013    3.001274    0.210611   -0.622044  0.068430\n",
-            "  57   -6.969984    2.997080    0.210312    0.350325  0.210013\n",
-            "  58   -7.012277    2.975084    0.205068   -0.644117  0.077586\n",
-            "  59   -7.012277    2.975084    0.205068   -0.644117  0.077586\n",
-            "  60   -6.988281    2.972775    0.200861    0.049524  0.175178\n",
-            "  61   -6.994996    2.950959    0.197558   -0.056943  0.161650\n",
-            "  62   -6.976329    2.909162    0.190642    0.209220  0.195894\n",
-            "  63   -6.976329    2.909162    0.190642    0.209220  0.195894\n",
-            "  64   -6.994568    2.894574    0.188754   -0.185511  0.156563\n",
-            "  65   -6.975221    2.881323    0.185425    0.094460  0.188218\n",
-            "  66   -6.998034    2.841964    0.182497   -0.717179  0.114774\n",
-            "  67   -6.998034    2.841964    0.182497   -0.717179  0.114774\n",
-            "  68   -6.974263    2.838935    0.177504    0.076290  0.189374\n",
-            "  69   -6.983781    2.818504    0.174190   -0.221376  0.168326\n",
-            "  70   -6.983781    2.818504    0.174190   -0.221376  0.168326\n",
-            "  71   -6.963725    2.806306    0.172787    0.263176  0.204231\n",
-            "  72   -6.983431    2.793633    0.169894   -0.231096  0.170732\n",
-            "  73   -6.983431    2.793633    0.169894   -0.231096  0.170732\n",
-            "  74   -6.963187    2.781740    0.167916    0.253447  0.203712\n",
-            "  75   -6.982687    2.768839    0.165454   -0.240646  0.173258\n",
-            "  76   -6.982687    2.768839    0.165454   -0.240646  0.173258\n",
-            "  77   -6.962278    2.757226    0.163152    0.244305  0.203420\n",
-            "  78   -6.962278    2.757226    0.163152    0.244305  0.203420\n",
-            "  79   -6.981564    2.744098    0.160859   -0.250060  0.175898\n",
-            "  80   -6.981564    2.744098    0.160859   -0.250060  0.175898\n",
-            "  81   -6.961008    2.732743    0.158477    0.235664  0.203350\n",
-            "  82   -6.961008    2.732743    0.158477    0.235664  0.203350\n",
-            "  83   -6.980072    2.719391    0.156100   -0.259400  0.178656\n",
-            "  84   -6.980072    2.719391    0.156100   -0.259400  0.178656\n",
-            "  85   -6.959384    2.708276    0.153876    0.227424  0.203511\n",
-            "  86   -6.978217    2.694698    0.151162   -0.268762  0.181555\n",
-            "  87   -6.978217    2.694698    0.151162   -0.268762  0.181555\n",
-            "  88   -6.957409    2.683809    0.149440    0.311989  0.203453\n",
-            "  89   -6.978263    2.672992    0.147213   -0.276480  0.183541\n",
-            "  90   -6.957349    2.662307    0.145089    0.303736  0.202969\n",
-            "  91   -6.978097    2.651358    0.143172   -0.284279  0.185647\n",
-            "  92   -6.957084    2.640868    0.140820    0.295691  0.202684\n",
-            "  93   -6.977718    2.629781    0.139048   -0.396189  0.184469\n",
-            "  94   -6.955378    2.621866    0.137610    0.368178  0.200461\n",
-            "  95   -6.977117    2.612681    0.135634   -0.402850  0.186835\n",
-            "  96   -6.954757    2.604834    0.134423    0.362112  0.200479\n",
-            "  97   -6.976444    2.595575    0.132204   -0.218839  0.192243\n",
-            "  98   -6.957083    2.582869    0.129202    0.351132  0.199394\n",
-            "  99   -6.957083    2.582869    0.129202    0.351132  0.199394\n",
-            " 100   -6.973769    2.575623    0.127741   -0.227469  0.195328\n",
-            " 101   -6.958679    2.566006    0.125291    0.342937  0.198730\n",
-            " 102   -6.958679    2.566006    0.125291    0.342937  0.198730\n",
-            " 103   -6.974323    2.559119    0.124633   -0.233956  0.196886\n",
-            " 104   -6.960020    2.550238    0.121717    0.257578  0.201363\n",
-            " 105   -6.960020    2.550238    0.121717    0.257578  0.201363\n",
-            " 106   -6.973798    2.542072    0.121133   -0.241216  0.199037\n",
-            " 107   -6.960120    2.533795    0.118413    0.328811  0.198331\n",
-            " 108   -6.960120    2.533795    0.118413    0.328811  0.198331\n",
-            " 109   -6.973841    2.527589    0.118249   -0.247354  0.200742\n",
-            " 110   -6.961043    2.520012    0.115381    0.322474  0.198134\n",
-            " 111   -6.961043    2.520012    0.115381    0.322474  0.198134\n",
-            " 112   -6.961043    2.520012    0.115381    0.322474  0.198134\n",
-            " 113   -6.967411    2.517095    0.114993   -0.148637  0.205148\n",
-            " 114   -6.962648    2.512364    0.113581    0.054147  0.205789\n",
-            " 115   -6.966686    2.500234    0.111405   -0.156395  0.207311\n",
-            " 116   -6.966686    2.500234    0.111405   -0.156395  0.207311\n",
-            " 117   -6.956935    2.490983    0.110905    0.314202  0.200379\n",
-            " 118   -6.969587    2.485041    0.108715   -0.162606  0.207722\n",
-            " 119   -6.969587    2.485041    0.108715   -0.162606  0.207722\n",
-            " 120   -6.959629    2.475990    0.107071    0.305766  0.199672\n",
-            " 121   -6.959629    2.475990    0.107071    0.305766  0.199672\n",
-            " 122   -6.972223    2.469973    0.106026   -0.274184  0.209143\n",
-            " 123   -6.960046    2.463347    0.104419    0.300193  0.199893\n",
-            " 124   -6.960046    2.463347    0.104419    0.300193  0.199893\n",
-            " 125   -6.972592    2.457270    0.103461   -0.280053  0.210840\n",
-            " 126   -6.960362    2.450736    0.101802    0.294692  0.200205\n",
-            " 127   -6.960362    2.450736    0.101802    0.294692  0.200205\n",
-            " 128   -6.972857    2.444596    0.100853   -0.286071  0.212644\n",
-            " 129   -6.960576    2.438153    0.099218    0.289257  0.200609\n",
-            " 130   -6.960576    2.438153    0.099218    0.289257  0.200609\n",
-            " 131   -6.973017    2.431949    0.098197   -0.292244  0.214557\n",
-            " 132   -6.960688    2.425595    0.096664    0.283883  0.201104\n",
-            " 133   -6.973072    2.419323    0.095492   -0.298585  0.216584\n",
-            " 134   -6.960695    2.413056    0.094136    0.278567  0.201692\n",
-            " 135   -6.973020    2.406716    0.092741   -0.199201  0.216363\n",
-            " 136   -6.962192    2.398610    0.090810    0.271322  0.201796\n",
-            " 137   -6.962192    2.398610    0.090810    0.271322  0.201796\n",
-            " 138   -6.973735    2.392552    0.089840   -0.312004  0.220810\n",
-            " 139   -6.961981    2.386816    0.088483    0.266437  0.202537\n",
-            " 140   -6.973465    2.380692    0.087155   -0.212337  0.220082\n",
-            " 141   -6.963035    2.373328    0.085471    0.259908  0.202880\n",
-            " 142   -6.963035    2.373328    0.085471    0.259908  0.202880\n",
-            " 143   -6.974444    2.367123    0.084398   -0.325089  0.225034\n",
-            " 144   -6.962611    2.361544    0.083185    0.255127  0.203802\n",
-            " 145   -6.973953    2.355270    0.081618   -0.225504  0.223942\n",
-            " 146   -6.973953    2.355270    0.081618   -0.225504  0.223942\n",
-            " 147   -6.963322    2.348164    0.080274    0.248854  0.204384\n",
-            " 148   -6.963322    2.348164    0.080274    0.248854  0.204384\n",
-            " 149   -6.974583    2.341805    0.078734   -0.232419  0.225885\n",
-            " 150   -6.974583    2.341805    0.078734   -0.232419  0.225885\n",
-            " 151   -6.963853    2.334832    0.077415    0.242715  0.205092\n",
-            " 152   -6.963853    2.334832    0.077415    0.242715  0.205092\n",
-            " 153   -6.975026    2.328387    0.075793   -0.239487  0.227986\n",
-            " 154   -6.975026    2.328387    0.075793   -0.239487  0.227986\n",
-            " 155   -6.964202    2.321544    0.074600    0.236702  0.205925\n",
-            " 156   -6.975284    2.315009    0.072791   -0.246720  0.230248\n",
-            " 157   -6.975284    2.315009    0.072791   -0.246720  0.230248\n",
-            " 158   -6.964370    2.308293    0.071882    0.321952  0.198711\n",
-            " 159   -6.976511    2.303288    0.070390   -0.252545  0.231723\n",
-            " 160   -6.965522    2.296681    0.069205    0.316248  0.198975\n",
-            " 161   -6.977625    2.291630    0.068016   -0.365118  0.238367\n",
-            " 162   -6.965588    2.286485    0.067194    0.398841  0.191389\n",
-            " 163   -6.978242    2.282504    0.066060   -0.369939  0.239978\n",
-            " 164   -6.966182    2.277410    0.065219    0.394823  0.191615\n",
-            " 165   -6.978824    2.273410    0.064087   -0.374805  0.241630\n",
-            " 166   -6.966743    2.268365    0.063265    0.390862  0.191872\n",
-            " 167   -6.979371    2.264347    0.062096   -0.379717  0.243322\n",
-            " 168   -6.967268    2.259350    0.061330    0.386958  0.192159\n",
-            " 169   -6.979883    2.255314    0.060085   -0.384675  0.245055\n",
-            " 170   -6.967760    2.250365    0.059412    0.383110  0.192475\n",
-            " 171   -6.980360    2.246310    0.058056   -0.389681  0.246829\n",
-            " 172   -6.968218    2.241408    0.057512    0.379317  0.192819\n",
-            " 173   -6.980803    2.237334    0.056006   -0.394733  0.248644\n",
-            " 174   -6.968642    2.232478    0.055629    0.375580  0.193191\n",
-            " 175   -6.981213    2.228385    0.053935   -0.399834  0.250500\n",
-            " 176   -6.969032    2.223576    0.053855    0.664202  0.160221\n",
-            " 177   -6.982338    2.221598    0.052745   -0.512056  0.256922\n",
-            " 178   -6.969726    2.217614    0.052440    0.661413  0.159963\n",
-            " 179   -6.983031    2.215640    0.051575   -0.622093  0.264229\n"
-          ],
-          "name": "stdout"
-        },
-        {
-          "output_type": "error",
-          "ename": "KeyboardInterrupt",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-74-f7865185f425>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mres\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mscipy_minimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_init_guess\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mjac\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrad_loss_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mhess\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mhess_loss_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'trust-constr'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'disp'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcallbackF\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_minimize.py\u001b[0m in \u001b[0;36mminimize\u001b[0;34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[0m\n\u001b[1;32m    620\u001b[0m         return _minimize_trustregion_constr(fun, x0, args, jac, hess, hessp,\n\u001b[1;32m    621\u001b[0m                                             \u001b[0mbounds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconstraints\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 622\u001b[0;31m                                             callback=callback, **options)\n\u001b[0m\u001b[1;32m    623\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mmeth\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'dogleg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    624\u001b[0m         return _minimize_dogleg(fun, x0, args, jac, hess,\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py\u001b[0m in \u001b[0;36m_minimize_trustregion_constr\u001b[0;34m(fun, x0, args, grad, hess, hessp, bounds, constraints, xtol, gtol, barrier_tol, sparse_jacobian, callback, maxiter, verbose, finite_diff_rel_step, initial_constr_penalty, initial_tr_radius, initial_barrier_parameter, initial_barrier_tolerance, factorization_method, disp)\u001b[0m\n\u001b[1;32m    517\u001b[0m             \u001b[0minitial_barrier_tolerance\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    518\u001b[0m             \u001b[0minitial_constr_penalty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial_tr_radius\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 519\u001b[0;31m             factorization_method)\n\u001b[0m\u001b[1;32m    520\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    521\u001b[0m     \u001b[0;31m# Status 3 occurs when the callback function requests termination,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/tr_interior_point.py\u001b[0m in \u001b[0;36mtr_interior_point\u001b[0;34m(fun, grad, lagr_hess, n_vars, n_ineq, n_eq, constr, jac, x0, fun0, grad0, constr_ineq0, jac_ineq0, constr_eq0, jac_eq0, stop_criteria, enforce_feasibility, xtol, state, initial_barrier_parameter, initial_tolerance, initial_penalty, initial_trust_radius, factorization_method)\u001b[0m\n\u001b[1;32m    327\u001b[0m             \u001b[0mconstr0_subprob\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjac0_subprob\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msubprob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_criteria\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    328\u001b[0m             \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial_penalty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrust_radius\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 329\u001b[0;31m             factorization_method, trust_lb, trust_ub, subprob.scaling)\n\u001b[0m\u001b[1;32m    330\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0msubprob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mterminate\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    331\u001b[0m             \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/equality_constrained_sqp.py\u001b[0m in \u001b[0;36mequality_constrained_sqp\u001b[0;34m(fun_and_constr, grad_and_jac, lagr_hess, x0, fun0, grad0, constr0, jac0, stop_criteria, state, initial_penalty, initial_trust_radius, factorization_method, trust_lb, trust_ub, scaling)\u001b[0m\n\u001b[1;32m    206\u001b[0m             \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mLS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m             \u001b[0;31m# Compute Hessian\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m             \u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlagr_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    209\u001b[0m             \u001b[0;31m# Set Flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    210\u001b[0m             \u001b[0mlast_iteration_failed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/tr_interior_point.py\u001b[0m in \u001b[0;36mlagrangian_hessian\u001b[0;34m(self, z, v)\u001b[0m\n\u001b[1;32m    224\u001b[0m         \u001b[0;34m\"\"\"Returns scaled Lagrangian Hessian\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    225\u001b[0m         \u001b[0;31m# Compute Hessian in relation to x and s\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 226\u001b[0;31m         \u001b[0mHx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlagrangian_hessian_x\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    227\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_ineq\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    228\u001b[0m             \u001b[0mS_Hs_S\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlagrangian_hessian_s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/tr_interior_point.py\u001b[0m in \u001b[0;36mlagrangian_hessian_x\u001b[0;34m(self, z, v)\u001b[0m\n\u001b[1;32m    203\u001b[0m         \u001b[0mv_ineq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_eq\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_eq\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_ineq\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    204\u001b[0m         \u001b[0mlagr_hess\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlagr_hess\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 205\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mlagr_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_eq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_ineq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    206\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mlagrangian_hessian_s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, x, v_eq, v_ineq)\u001b[0m\n\u001b[1;32m     49\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_eq\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mempty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_ineq\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mempty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m         \u001b[0mH_objective\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobjective_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0mH_constraints\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstraints_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_eq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv_ineq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mhess\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    190\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray_equal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    191\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_x_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 192\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    193\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    194\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36m_update_hess\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    172\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_update_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    173\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH_updated\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 174\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_hess_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    175\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH_updated\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    176\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mupdate_hess\u001b[0;34m()\u001b[0m\n\u001b[1;32m    117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    118\u001b[0m             \u001b[0;32mdef\u001b[0m \u001b[0mupdate_hess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhess_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    120\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    121\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mhess\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mFD_METHODS\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mhess_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m    113\u001b[0m                 \u001b[0;32mdef\u001b[0m \u001b[0mhess_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    114\u001b[0m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnhev\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0matleast_2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0matleast_2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mH\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mjacfun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    964\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_input_dtype_jacfwd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    965\u001b[0m     \u001b[0mpushfwd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 966\u001b[0;31m     \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpushfwd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_std_basis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    967\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_output_dtype_jacfwd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    968\u001b[0m     \u001b[0mexample_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margnums\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    160\u001b[0m     \u001b[0m__tracebackhide__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    164\u001b[0m       \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfiltering_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mbatched_fun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1285\u001b[0m         \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_axes_flat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1286\u001b[0m         \u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mflatten_axes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"vmap out_axes\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_axes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1287\u001b[0;31m     ).call_wrapped(*args_flat)\n\u001b[0m\u001b[1;32m   1288\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1289\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m       \u001b[0;31m# Some transformations yield from inside context managers, so we have to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_jvp\u001b[0;34m(fun, primals, tangents)\u001b[0m\n\u001b[1;32m   1930\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1931\u001b[0m   \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun_nokwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtree_def\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1932\u001b[0;31m   \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tangents\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mad\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjvp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mps_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1933\u001b[0m   return (tree_unflatten(out_tree(), out_primals),\n\u001b[1;32m   1934\u001b[0m           tree_unflatten(out_tree(), out_tangents))\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m       \u001b[0;31m# Some transformations yield from inside context managers, so we have to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mjacfun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1031\u001b[0m     \u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margnums_partial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margnums\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1032\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_input_dtype_jacrev\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_int\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1033\u001b[0;31m     \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpullback\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_vjp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mdyn_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1034\u001b[0m     \u001b[0mtree_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_output_dtype_jacrev\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mholomorphic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1035\u001b[0m     \u001b[0mjac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpullback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_std_basis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_vjp\u001b[0;34m(fun, has_aux, reduce_axes, *primals)\u001b[0m\n\u001b[1;32m   2135\u001b[0m     \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun_nokwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2136\u001b[0m     out_primal, out_vjp = ad.vjp(\n\u001b[0;32m-> 2137\u001b[0;31m         flat_fun, primals_flat, reduce_axes=reduce_axes)\n\u001b[0m\u001b[1;32m   2138\u001b[0m     \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2139\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mvjp\u001b[0;34m(traceable, primals, has_aux, reduce_axes)\u001b[0m\n\u001b[1;32m    113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvjp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    114\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m     \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinearize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m     \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinearize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mlinearize\u001b[0;34m(traceable, *primals, **kwargs)\u001b[0m\n\u001b[1;32m    100\u001b[0m   \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_flatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m   \u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m   \u001b[0mout_primals_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tangents_pvals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m   \u001b[0;32massert\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_primal_pval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_known\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mout_primal_pval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mout_primals_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr\u001b[0;34m(fun, pvals, instantiate)\u001b[0m\n\u001b[1;32m    503\u001b[0m   \u001b[0;32mwith\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_main\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mJaxprTrace\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    504\u001b[0m     \u001b[0mfun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstantiate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 505\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    506\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    507\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m       \u001b[0;31m# Some transformations yield from inside context managers, so we have to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    160\u001b[0m     \u001b[0m__tracebackhide__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    164\u001b[0m       \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfiltering_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mcache_miss\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    406\u001b[0m         \u001b[0mflat_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs_flat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    407\u001b[0m         \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 408\u001b[0;31m         donated_invars=donated_invars, inline=inline)\n\u001b[0m\u001b[1;32m    409\u001b[0m     \u001b[0mout_pytree_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    410\u001b[0m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_pytree_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    316\u001b[0m     new_params = (update_params(params, nz_tangents, nz_tangents_out)\n\u001b[1;32m    317\u001b[0m                   if update_params else params)\n\u001b[0;32m--> 318\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mnonzero_tangents\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mnew_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m     \u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree_def\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    320\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mJVPTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    193\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    194\u001b[0m       jaxpr, out_pvals, consts, env_tracers = self.partial_eval(\n\u001b[0;32m--> 195\u001b[0;31m           f, in_pvals, app, instantiate=False)\n\u001b[0m\u001b[1;32m    196\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap_primitive\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    197\u001b[0m         \u001b[0munmapped_aval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munmapped_aval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'axis_size'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mpartial_eval\u001b[0;34m(self, f, pvals, app, instantiate)\u001b[0m\n\u001b[1;32m    301\u001b[0m     \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstantiate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    302\u001b[0m     \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial_eval_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 303\u001b[0;31m     \u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0min_consts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    304\u001b[0m     \u001b[0mout_consts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msplit_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjaxpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstvars\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    305\u001b[0m     \u001b[0mout_pvs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPartialVal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_consts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    316\u001b[0m     new_params = (update_params(params, nz_tangents, nz_tangents_out)\n\u001b[1;32m    317\u001b[0m                   if update_params else params)\n\u001b[0;32m--> 318\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mnonzero_tangents\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mnew_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m     \u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree_def\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    320\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mJVPTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/batching.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    157\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    158\u001b[0m       \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch_subtrace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 159\u001b[0;31m       \u001b[0mvals_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    160\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mBatchTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvals_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1603\u001b[0m       params_tuple, out_axes_transforms)\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1607\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1619\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mpost_process\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    612\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 613\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    614\u001b[0m   \u001b[0mprocess_map\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_call_impl\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m    618\u001b[0m   \u001b[0;32mdel\u001b[0m \u001b[0minline\u001b[0m  \u001b[0;31m# Only used at tracing time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    619\u001b[0m   compiled_fun = _xla_callable(fun, device, backend, name, donated_invars,\n\u001b[0;32m--> 620\u001b[0;31m                                *unsafe_map(arg_spec, args))\n\u001b[0m\u001b[1;32m    621\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    622\u001b[0m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompiled_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mmemoized_fun\u001b[0;34m(fun, *args)\u001b[0m\n\u001b[1;32m    260\u001b[0m       \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulate_stores\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    261\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 262\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    263\u001b[0m       \u001b[0mcache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mans\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    264\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_callable\u001b[0;34m(fun, device, backend, name, donated_invars, *arg_specs)\u001b[0m\n\u001b[1;32m    770\u001b[0m       device_assignment=(device.id,) if device else None)\n\u001b[1;32m    771\u001b[0m   \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameter_is_tupled_arguments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtuple_args\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 772\u001b[0;31m   \u001b[0mcompiled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompile_or_get_cached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuilt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    773\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mnreps\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    774\u001b[0m     return partial(_execute_compiled, compiled, out_avals, result_handlers,\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36mcompile_or_get_cached\u001b[0;34m(backend, computation, compile_options)\u001b[0m\n\u001b[1;32m     79\u001b[0m             \u001b[0mcc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mput_executable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomputation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mbackend_compile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomputation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     82\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0midentity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36mbackend_compile\u001b[0;34m(backend, built_c, options)\u001b[0m\n\u001b[1;32m    383\u001b[0m   \u001b[0;31m# we use a separate function call to ensure that XLA compilation appears\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    384\u001b[0m   \u001b[0;31m# separately in Python profiling results\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 385\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilt_c\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile_options\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    386\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    387\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_execute_compiled_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompiled\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult_handler\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "iQ1eX-9m9PtW"
-      },
-      "source": [
-        "#np.save(Folder+'/Images/history_trust-constr_hess.npy',history)\n",
-        "history_trust_constr_hess=np.load(Folder+'/Images/history_trust-constr_hess.npy',allow_pickle=True)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "fgWVwwqiOUL6"
-      },
-      "source": [
-        "history=history_trust_constr_hess"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "UXcywbx_tU6C"
-      },
-      "source": [
-        "loss_history=np.array([loss_func(x) for x in history])\n",
-        "grads_history=np.array([grad_loss_func(x) for x in history])"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 597
-        },
-        "id": "v9AQdBMatW6l",
-        "outputId": "38f34d55-6e86-41aa-dfee-501a956b44f9"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
-        "\n",
-        "ax[0].plot(history[:,0],label='Fitting')\n",
-        "ax[0].set_title('Log(Amp)')\n",
-        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
-        "#ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
-        "#ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
-        "ax[0].legend()\n",
-        "\n",
-        "\n",
-        "\n",
-        "grads_history=np.array(grads_history)\n",
-        "loss_history=np.array(loss_history)\n",
-        "\n",
-        "ax[1].plot(np.abs(grads_history[:,0]))\n",
-        "ax[1].set_yscale('log')\n",
-        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
-        "\n",
-        "\n",
-        "ax[2].plot(history[:,1],label='Fitting')\n",
-        "ax[2].set_title('Beta')\n",
-        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
-        "ax[2].legend()\n",
-        "\n",
-        "ax[3].plot(np.abs(grads_history[:,1]))\n",
-        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
-        "ax[3].set_yscale('log')\n",
-        "\n",
-        "\n",
-        "\n",
-        "ax[4].plot(loss_history)\n",
-        "ax[4].set_yscale('log')\n",
-        "ax[4].set_title('Loss')\n",
-        "\n",
-        "fig.tight_layout()\n",
-        "fig.suptitle('weighted MAE loss',y=1.1)\n",
-        "\n",
-        "\n",
-        "\n",
-        "fig.add_subplot(111, frameon=False)\n",
-        "# hide tick and tick label of the big axis\n",
-        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
-        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1440x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "evdwjjYsF2Mp"
-      },
-      "source": [
-        "### only jac"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "ssQE2yZXtXFb",
-        "outputId": "9a809710-2b85-47a1-8420-c080171e24aa"
-      },
-      "source": [
-        "Nfeval = 1\n",
-        "history=np.zeros((0,2))\n",
-        "init_guess=np.array([0.,GRF_beta])\n",
-        "bounds=((-10., -0.), (1., 6.0))\n",
-        "\n",
-        "def callbackF(Xi,optimizer):\n",
-        "    global Nfeval\n",
-        "    global history\n",
-        "    loss=loss_func(Xi)\n",
-        "    grad=grad_loss_func(Xi)\n",
-        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
-        "    Nfeval += 1\n",
-        "    history=np.append(history,[Xi],axis=0)\n",
-        "\n",
-        "\n",
-        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "   1   -0.035741    4.949092    207.091483    0.137991 -2.910105\n",
-            "   2   -0.424350    5.356864    207.314332    0.008007  0.407781\n",
-            "   3   -0.431992    5.313520    207.311712    0.003525  0.012143\n",
-            "   4   -0.431992    5.313520    207.311712    0.003525  0.012143\n",
-            "   5   -0.431992    5.313520    207.311712    0.003525  0.012143\n",
-            "   6   -0.436854    5.311473    207.311669    0.003739  0.012419\n",
-            "   7   -0.441763    5.309396    207.311624    0.003970  0.012851\n",
-            "   8   -0.446726    5.307272    207.311575    0.004221  0.013452\n",
-            "   9   -0.451755    5.305082    207.311523    0.004496  0.014247\n",
-            "  10   -0.456862    5.302805    207.311466    0.004799  0.015270\n",
-            "  11   -0.462061    5.300414    207.311402    0.005137  0.016572\n",
-            "  12   -0.467368    5.297880    207.311330    0.005519  0.018223\n",
-            "  13   -0.472807    5.295164    207.311246    0.005959  0.020327\n",
-            "  14   -0.478405    5.292215    207.311148    0.006473  0.023023\n",
-            "  15   -0.484199    5.288968    207.311028    0.007088  0.026501\n",
-            "  16   -0.490237    5.285335    207.310879    0.007842  0.030990\n",
-            "  17   -0.491335    5.281023    207.310726    0.008587  0.035966\n",
-            "  18   -0.492462    5.276185    207.310528    0.009519  0.041437\n",
-            "  19   -0.493634    5.270758    207.310278    0.010648  0.045645\n",
-            "  20   -0.494870    5.264862    207.309995    0.011870  0.044719\n",
-            "  21   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
-            "  22   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
-            "  23   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
-            "  24   -0.640023    4.762026    207.125738   -0.078073  2.167740\n",
-            "  25   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
-            "  26   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
-            "  27   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
-            "  28   -0.624203    3.810045    207.030035    1.410778 -9.505034\n",
-            "  29   -0.631694    3.944712    206.771223    1.747185  8.995471\n",
-            "  30   -0.631694    3.944712    206.771223    1.747185  8.995471\n",
-            "  31   -0.631694    3.944712    206.771223    1.747185  8.995471\n",
-            "  32   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
-            "  33   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
-            "  34   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
-            "  35   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
-            "  36   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
-            "  37   -0.634192    3.911361    206.017635    3.650267 -61.328762\n",
-            "  38   -0.634361    3.918717    205.797457    3.815107  19.592749\n",
-            "  39   -0.643190    3.914915    205.796233    4.214211 -36.744026\n",
-            "  40   -0.652298    3.917299    205.711318    4.193017 -0.091102\n",
-            "  41   -0.717507    3.920806    205.570851    3.730697  67.073334\n",
-            "  42   -0.856677    3.916114    204.615300    6.382287  37.682571\n",
-            "  43   -1.943516    3.907607    198.627578    0.925284  88.272267\n",
-            "  44   -2.354892    3.897963    192.153963    22.140011  40.565561\n",
-            "  45   -7.294712    3.843118    0.449401   -1.252996 -0.320715\n",
-            "  46   -7.294712    3.843118    0.449401   -1.252996 -0.320715\n",
-            "  47   -7.294712    3.843118    0.449401   -1.252996 -0.320715\n",
-            "  48   -7.152337    3.841766    0.366107    0.484929  0.296541\n",
-            "  49   -7.214154    3.841547    0.356168   -0.555669 -0.063573\n",
-            "  50   -7.181117    3.841647    0.355137    0.255803  0.211960\n",
-            "  51   -7.191502    3.841599    0.352837    0.147883  0.174043\n",
-            "  52   -7.205689    3.841518    0.352314   -0.361640  0.002803\n",
-            "  53   -7.195610    3.841559    0.352226    0.146139  0.172325\n",
-            "  54   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
-            "  55   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
-            "  56   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
-            "  57   -7.198498    3.841531    0.351801    0.144923  0.171128\n",
-            "  58   -7.203140    3.841462    0.351680   -0.159856  0.067183\n",
-            "  59   -7.203140    3.841462    0.351680   -0.159856  0.067183\n",
-            "  60   -7.200889    3.841466    0.351603    0.043097  0.136283\n",
-            "  61   -7.201768    3.841435    0.351592   -0.058797  0.103612\n",
-            "  62   -7.201285    3.841434    0.351581    0.043017  0.136150\n",
-            "  63   -7.201478    3.841416    0.351573   -0.058821  0.103685\n",
-            "  64   -7.201478    3.841416    0.351573   -0.058821  0.103685\n",
-            "  65   -7.201389    3.841366    0.351568    0.042976  0.136110\n",
-            "  66   -7.201620    3.840723    0.351509   -0.058987  0.103621\n",
-            "  67   -7.200847    3.839571    0.351346    0.042480  0.136135\n",
-            "  68   -7.197730    3.830531    0.350243    0.040034  0.136396\n",
-            "  69   -7.190141    3.810756    0.347821    0.034713  0.137272\n",
-            "  70   -7.182349    3.790505    0.345298    0.130343  0.170992\n",
-            "  71   -7.129484    3.648099    0.326441    0.189485  0.205147\n",
-            "  72   -7.129484    3.648099    0.326441    0.189485  0.205147\n",
-            "  73   -7.129484    3.648099    0.326441    0.189485  0.205147\n",
-            "  74   -7.142139    3.595737    0.324840   -0.829791 -0.077609\n",
-            "  75   -7.104735    3.598753    0.320712    0.176230  0.210812\n",
-            "  76   -7.100287    3.545210    0.310274    0.150602  0.206386\n",
-            "  77   -7.080791    3.169565    0.295208   -1.635611 -0.083293\n",
-            "  78   -6.990308    2.805311    0.173775   -0.326566  0.159380\n",
-            "  79   -6.990308    2.805311    0.173775   -0.326566  0.159380\n",
-            "  80   -6.978760    2.740722    0.159559   -0.252105  0.177217\n",
-            "  81   -6.968345    2.675363    0.146447   -0.084837  0.192216\n",
-            "  82   -6.903430    2.220487    0.140182    2.036467 -0.166330\n",
-            "  83   -6.951547    2.515899    0.117652    0.329173  0.202077\n",
-            "  84   -6.945788    2.427485    0.104338    0.766408  0.173795\n",
-            "  85   -6.943547    2.118610    0.080038    2.253988 -0.345901\n",
-            "  86   -6.955498    2.300492    0.075668    0.709605  0.165560\n",
-            "  87   -6.964633    2.232445    0.058226    0.674310  0.161521\n",
-            "  88   -6.964633    2.232445    0.058226    0.674310  0.161521\n",
-            "  89   -7.030850    1.886201    0.035184   -0.951630 -0.037996\n",
-            "  90   -7.030850    1.886201    0.035184   -0.951630 -0.037996\n",
-            "  91   -6.995145    2.055367    0.013964   -1.040364  0.334968\n",
-            "  92   -6.995145    2.055367    0.013964   -1.040364  0.334968\n",
-            "  93   -6.995145    2.055367    0.013964   -1.040364  0.334968\n",
-            "  94   -6.999754    1.985130    0.007279    2.267917 -0.457693\n",
-            "  95   -6.999754    1.985130    0.007279    2.267917 -0.457693\n",
-            "  96   -7.005029    1.985710    0.006027   -1.280828  0.031835\n",
-            "  97   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
-            "  98   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
-            "  99   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
-            " 100   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
-            " 101   -7.002073    1.985674    0.003425   -0.258579 -0.201569\n",
-            " 102   -7.001737    1.985818    0.003391    0.244545 -0.269760\n",
-            " 103   -7.001976    1.986361    0.003262   -0.258870 -0.201538\n",
-            " 104   -7.001597    1.987470    0.002980    0.137035 -0.255777\n",
-            " 105   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
-            " 106   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
-            " 107   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
-            " 108   -7.000704    1.995453    0.001101   -0.349474 -0.188062\n",
-            " 109   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
-            " 110   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
-            " 111   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
-            " 112   -6.999510    2.001522    0.000588    1.295227 -0.030480\n",
-            " 113   -6.999925    2.001528    0.000513   -2.246569  0.445733\n",
-            " 114   -6.999925    2.001528    0.000513   -2.246569  0.445733\n",
-            " 115   -6.999719    2.001506    0.000389    0.652224  0.137145\n",
-            " 116   -6.999719    2.001506    0.000389    0.652224  0.137145\n",
-            " 117   -6.999772    2.001453    0.000353    0.352092  0.187890\n",
-            " 118   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
-            " 119   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
-            " 120   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
-            " 121   -6.999842    2.000997    0.000243    0.351893  0.187904\n",
-            " 122   -6.999872    2.000989    0.000235   -0.029692  0.241174\n",
-            " 123   -6.999861    2.000942    0.000226    0.265198  0.200894\n",
-            " 124   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
-            " 125   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
-            " 126   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
-            " 127   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
-            " 128   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
-            " 129   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
-            " 130   -6.999928    2.000610    0.000146   -0.336934  0.279244\n",
-            " 131   -6.999916    2.000604    0.000144    0.174463  0.213762\n",
-            " 132   -6.999916    2.000604    0.000144    0.174463  0.213762\n",
-            " 133   -6.999925    2.000596    0.000142   -0.237093  0.267345\n",
-            " 134   -6.999923    2.000524    0.000126    0.265013  0.200912\n",
-            " 135   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 136   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 137   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 138   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 139   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 140   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 141   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 142   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 143   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 144   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 145   -6.999999    2.000018    0.000005   -1.925851  0.425768\n",
-            " 146   -6.999997    2.000017    0.000005    0.651523  0.137089\n",
-            " 147   -6.999997    2.000017    0.000005    0.651523  0.137089\n",
-            " 148   -6.999997    2.000017    0.000004    0.351460  0.187931\n",
-            " 149   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
-            " 150   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
-            " 151   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
-            " 152   -6.999998    2.000012    0.000003    0.351458  0.187931\n",
-            " 153   -6.999999    2.000012    0.000003   -0.030162  0.241285\n",
-            " 154   -6.999998    2.000011    0.000003    0.264787  0.200935\n",
-            " 155   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
-            " 156   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
-            " 157   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
-            " 158   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
-            " 159   -6.999999    2.000007    0.000002   -0.337252  0.279356\n",
-            " 160   -6.999999    2.000007    0.000002    0.264786  0.200935\n",
-            " 161   -6.999999    2.000007    0.000002   -0.642877  0.313361\n",
-            " 162   -6.999999    2.000006    0.000001    0.174194  0.213800\n",
-            " 163   -7.000000    2.000004    0.000001   -0.237392  0.267441\n",
-            " 164   -7.000000    2.000004    0.000001   -0.237392  0.267441\n",
-            " 165   -7.000000    2.000004    0.000001   -0.237392  0.267441\n",
-            " 166   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
-            " 167   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
-            " 168   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
-            " 169   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
-            " 170   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
-            " 171   -7.000000    1.999999    0.000000    1.925866 -0.425779\n",
-            " 172   -7.000000    1.999999    0.000000   -0.351452 -0.187932\n",
-            " 173   -7.000000    1.999999    0.000000   -0.351452 -0.187932\n",
-            " 174   -7.000000    1.999999    0.000000   -0.174191 -0.213801\n",
-            " 175   -7.000000    1.999999    0.000000   -0.079316 -0.226824\n",
-            " 176   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
-            " 177   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
-            " 178   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
-            " 179   -7.000000    2.000001    0.000000   -0.337255  0.279357\n",
-            " 180   -7.000000    2.000001    0.000000    0.651515  0.137089\n",
-            " 181   -7.000000    2.000000    0.000000    0.174192  0.213801\n",
-            " 182   -7.000000    2.000000    0.000000   -2.248032  0.446728\n",
-            " 183   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 184   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 185   -7.000000    2.000000    0.000000   -0.834370 -0.093982\n",
-            " 186   -7.000000    2.000000    0.000000   -0.834370 -0.093982\n",
-            " 187   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 188   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 189   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 190   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 191   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 192   -7.000000    2.000000    0.000000    2.248032 -0.446728\n",
-            " 193   -7.000000    2.000000    0.000000   -2.248032  0.446728\n",
-            " 194   -7.000000    2.000000    0.000000    1.293971 -0.030625\n",
-            " 195   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 196   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 197   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 198   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 199   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 200   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 201   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 202   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 203   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 204   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 205   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 206   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 207   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 208   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 209   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 210   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 211   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 212   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 213   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 214   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 215   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 216   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 217   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 218   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 219   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 220   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 221   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 222   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 223   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 224   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 225   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 226   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 227   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 228   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 229   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 230   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 231   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 232   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 233   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 234   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 235   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 236   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 237   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 238   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 239   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 240   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 241   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 242   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 243   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 244   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 245   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 246   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 247   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 248   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 249   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 250   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 251   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 252   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 253   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 254   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 255   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 256   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 257   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 258   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 259   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 260   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 261   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 262   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 263   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 264   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 265   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 266   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 267   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 268   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 269   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 270   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 271   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 272   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 273   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 274   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 275   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 276   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 277   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 278   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 279   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 280   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 281   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 282   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 283   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 284   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 285   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 286   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 287   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 288   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 289   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 290   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 291   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 292   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 293   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 294   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 295   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 296   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 297   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 298   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 299   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 300   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 301   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 302   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 303   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 304   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 305   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 306   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 307   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 308   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 309   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 310   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 311   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 312   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 313   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 314   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 315   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 316   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 317   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 318   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 319   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 320   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 321   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            " 322   -7.000000    2.000000    0.000000    0.651515  0.137089\n",
-            "`xtol` termination condition is satisfied.\n",
-            "Number of iterations: 322, function evaluations: 416, CG iterations: 457, optimality: 5.76e-01, constraint violation: 0.00e+00, execution time: 4.2e+01 s.\n"
-          ],
-          "name": "stdout"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "pBcPJ6lLtXQd"
-      },
-      "source": [
-        "#np.save(Folder+'/Images/history_trust-constr_jac_tight_bounds.npy',history)\n",
-        "\n",
-        "#Bounds ((-10.,0.),(1.,10.))\n",
-        "history_trust_constr_jac_loose_bounds=np.load(Folder+'/Images/history_trust-constr_jac_loose_bounds.npy',allow_pickle=True)\n",
-        "\n",
-        "#Bounds ((-10.,0.),(1.,6.))\n",
-        "history_trust_constr_jac_tight_bounds=np.load(Folder+'/Images/history_trust-constr_jac_tight_bounds.npy',allow_pickle=True)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "R1NH-OqwKx6j"
-      },
-      "source": [
-        "history=history_trust_constr_jac_loose_bounds"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "bNJsnrjyGHFg"
-      },
-      "source": [
-        "loss_history=np.array([loss_func(x) for x in history])\n",
-        "grads_history=np.array([grad_loss_func(x) for x in history])"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 597
-        },
-        "id": "C-hkCokuGHO1",
-        "outputId": "30921ea8-d3a4-4a1e-8f5c-b05c47c1874d"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
-        "\n",
-        "ax[0].plot(history[:,0],label='Fitting')\n",
-        "ax[0].set_title('Log(Amp)')\n",
-        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
-        "ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
-        "ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
-        "ax[0].legend()\n",
-        "\n",
-        "\n",
-        "\n",
-        "grads_history=np.array(grads_history)\n",
-        "loss_history=np.array(loss_history)\n",
-        "\n",
-        "ax[1].plot(np.abs(grads_history[:,0]))\n",
-        "ax[1].set_yscale('log')\n",
-        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
-        "\n",
-        "\n",
-        "ax[2].plot(history[:,1],label='Fitting')\n",
-        "ax[2].set_title('Beta')\n",
-        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
-        "ax[2].legend()\n",
-        "\n",
-        "ax[3].plot(np.abs(grads_history[:,1]))\n",
-        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
-        "ax[3].set_yscale('log')\n",
-        "\n",
-        "\n",
-        "\n",
-        "ax[4].plot(loss_history)\n",
-        "ax[4].set_yscale('log')\n",
-        "ax[4].set_title('Loss')\n",
-        "\n",
-        "fig.tight_layout()\n",
-        "fig.suptitle('weighted MAE loss',y=1.1)\n",
-        "\n",
-        "\n",
-        "\n",
-        "fig.add_subplot(111, frameon=False)\n",
-        "# hide tick and tick label of the big axis\n",
-        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
-        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1440x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "wQJOF7jjU-rS"
-      },
-      "source": [
-        "## MSE loss function"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "S2eydSBcGQ_s"
-      },
-      "source": [
-        "#Pick spectrum loss type (weighted MSE or weighted MAE)\n",
-        "Spectra_Loss_pure=purify_function(Spectra_Loss_MSE,resid_true_spectrum)\n",
-        "GRF_Loss_args=(GRF_seed,unperturbed_image,get_jaxified_GRF_pure,simulate_perturbed_image_pure,compute_radial_spectrum_pure,Spectra_Loss_pure)\n",
-        "\n",
-        "#Precompile GRF_Loss \n",
-        "GRF_Loss_pure=purify_function(GRF_Loss,*GRF_Loss_args)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "C8o2ZWBdGHa9"
-      },
-      "source": [
-        "loss_func=GRF_Loss_pure\n",
-        "grad_loss_func=jax.grad(GRF_Loss_pure)\n",
-        "hess_loss_func=jax.jacfwd(jax.jacrev(loss_func))"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 332
-        },
-        "id": "peWh2ReHVGq5",
-        "outputId": "f541fd69-a7e5-4ac3-f260-e2214e2a4d79"
-      },
-      "source": [
-        "print('Loss: Guess={:.2f}, True:{:.2f}'.format(loss_func(GRF_init_guess),loss_func([GRF_LogAmp,GRF_beta])))\n",
-        "grad_loss=grad_loss_func(GRF_init_guess)\n",
-        "print('Grad Loss in guess: grad(logA)={:.2f}, grad(Beta)={:.2f}'.format(grad_loss[0],grad_loss[1]))\n",
-        "\n",
-        "hess_loss=hess_loss_func(GRF_init_guess)\n",
-        "sns.heatmap(np.log10(np.abs(hess_loss)),xticklabels=['logA','Beta'],yticklabels=['logA','Beta'],annot=True,fmt='.2f')\n",
-        "plt.title('Log(Abs(Hessian))')"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "Loss: Guess=93898.53, True:0.00\n",
-            "Grad Loss in guess: grad(logA)=124.37, grad(Beta)=-2654.02\n"
-          ],
-          "name": "stdout"
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "Text(0.5, 1.0, 'Log(Abs(Hessian))')"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 215
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAEICAYAAAD8yyfzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAfBUlEQVR4nO3de5xd473H8c93JhNDEglC5CbE/X5vFIeg1KWlrqEUpY3SarVap2ipUKWlpRdtUy1BKUVc6holFBUiN4lQ4iCIWy4TSSTMzO/8sVfSnW1m7z2yZ+2Zle/7vNbL3ut51rOeSXN++c1vPWstRQRmZpaOmmpPwMxsZeKga2aWIgddM7MUOeiamaXIQdfMLEUOumZmKXLQXQlJ+rykO9rQf6ykr33Kc50i6YpPc2ylSFogaXAFxjld0qUF+56WtOWKjm0rDwfdDk7Sq5I+V+FhfwpcUnAeSXpF0vOVOomkrsCPgF8k39eXFJK6FPS7VtJFlTpvoYjoHhGvVGCoPwHHSlonb99lwIgKjG0rCQfdlYyknYGeEfFUQdMewDrA4KRPJRwCvBARb1ZovKqKiMXAfcDxebvvAvaStG51ZmWdjYNuJyRpFUlXSHor2a6QtEpe+1mSZiVtX0uyy42S5gOAR1sY9gTgTuDe5HOhDZNfpedLulPSmsm56iXdIGm2pHmSnpHUp8S5Sv18u0h6MhlvsqSheW0nJhn5B5L+T9Kxyf6NJD0qqUHS+5Juzjtm2c8v6SBJE5OfY6akn+T1W5qJnyDp9WSccwumNxY4aOmXJBA/C3y+rT+nrZwcdDunc4FdgO2AbYHPkPs1Hkn7A98DPgdsBAwtOHZr4MX8HZJWA44A/ppsRyelgXzHAycBfYFG4NfJ/hOAnsBAYC3gG8CHrZ2rFEn9gXuAi4A1ge8Dt0laW1K35LwHREQPYFdgUnLohcCDwBrAAOA3rZxiYfKz9CIXPE+V9KWCPrsDmwL7AOdJ2jyvbTq5P3NK7DNrkYNu53QsMCIi3o2I94ALgK8kbUcB10TEtIhYBPyk4NhewAcF+w4DlpALWvcAdeRlc4nrI2JqRCwEfgwcJakW+JhcsN0oIpoi4tmImF/kXADvJ1nsPEnzgC/ntR0H3BsR90ZEc0SMAcYDBybtzcBWklaNiFkRMS3Z/zEwCOgXEYsj4vGW/uAiYmxEPJeMPQW4CdizoNsFEfFhREwGJrN8QP2A3D8yFOzr1dL5zAo56HZO/YDX8r6/luxb2jYzry3/M8BcoEfBvhOAWyKiMfl1+TY+WWLIH+c1coG5N3A98ADwt6Sc8XNJdUXOBdA7Inot3YAb89oGAUcWBOXdgb5JwB9GLpueJekeSZslx50FCHha0jRJJ7VwXiQNkfSIpPckNSRj9S7o9nbe50VA97zvPYCGgv49gHktnc+skINu5/QWueC01HrJPoBZ5H69XmpgwbFTgE2WfpE0ANgbOE7S25LeJldqOFBSfjDKH2c9cpnl+xHxcURcEBFbkPt1/wv890LTcucq00xyWXWvvK1bRFwCEBEPRMS+5MocL5BbUUBEvB0RX4+IfsApwFV5dex8N5K7+DUwInoCfyAXrMu1Obnst9Q+sxY56HYOdckFq3pJ9eR+Jf5RUufsDZwH3JD0vQX4qqTNk1rtjwvGupflf53+CvAfcjXM7ZJtE+AN4Ji8fsdJ2iIZcwRwa0Q0SdpL0tZJqWE+uWDc3Mq5ynED8MVkLXFt8jMPlTRAUh9JhyS13SXAgqXnknRk8g8I5DLsyJtHvh7AnIhYLOkzLF/aKMee5FYwkJy3HtgRGNPGcWwl5aDbOdxL7uLU0q2eXJ1zCvAcMIHchSci4j5yF5seAV4Gli4NW5K0TwAaJA1J9p8AXJVkiss2chlgfonheuBacr961wPfTvavC9xKLuBOJ7da4fqk7W5gM0n9KFNEzCS31Owc4D1yme8PyP1drSF3kfAtYA65AHhqcujOwDhJC8hlst9pZW3uacAISR+Q+8fqlnLnlgTYA4FRebu/CIyNiLdaPspsefJDzLMtufI+FVglIhqTffsBp0VE4VX79jj/cGCLiDijvc/V3iSdTq4scVbevnHAyRExtXozs87EQTeDJB1KLjtejVxW1pxGgDWz0lxeyKZTgHeBGUAT//0V3MyqzJmumVmKnOmamaWoS+kuK3iCrv2dStsnPNF7SOlOttIZ8tbtbVkz3aKP33+l7JhT13vwCp+vrZzpmpmlqN0zXTOzVDU3VXsGRTnomlm2NDVWewZFOeiaWaZEtHT3d8fhoGtm2dLsoGtmlh5numZmKfKFNDOzFDnTNTNLT3j1gplZinwhzcwsRS4vmJmlyBfSzMxS5EzXzCxFvpBmZpYiX0gzM0tPhGu6ZmbpcU3XzCxFLi+YmaXIma6ZWYqaPq72DIpy0DWzbHF5wcwsRS4vmJmlyJmumVmKHHTNzNITFbyQJulV4AOgCWiMiJ0K2gVcCRwILAJOjIgJxcZ00DWzbKl8TXeviHi/lbYDgI2TbQjw++S/rXLQNbNsSbe8cAhwXUQE8JSkXpL6RsSs1g6oSW9uZmYpiOayN0nDJY3P24YXjgY8KOnZFtoA+gMz876/kexrlTNdM8uWNmS6ETESGFmky+4R8aakdYAxkl6IiMdWZHrOdM0sW9qQ6ZYcKuLN5L/vAqOBzxR0eRMYmPd9QLKvVQ66ZpYtjY3lb0VI6iapx9LPwH7A1IJudwHHK2cXoKFYPRdcXjCzrKnc6oU+wOjcqjC6ADdGxP2SvgEQEX8A7iW3XOxlckvGvlpqUAddM8uWCq1eiIhXgG1b2P+HvM8BfLMt4zromlm2+NkLZmYp8m3AZmYpcqZrZpaiEqsSqs1B18yyJaLaMyjKQdfMssU1XTOzFDnompmlyBfSzMxS1NRU7RkU5aBrZtni8oKZWYocdM3MUuSarplZeqLZ63TNzNLj8oKZWYq8esHMLEXOdM3MUtTBg67fkVYBfxp5OW+9MZlJE//ZYvvqq/fgjtHX8uz4MUye9DAnHH8UAEP33JXxzzy4bFswfwYHH/z5NKdu7Uir1LHlPZey1ZhfsvUjV9D/+8Na7LfmF3dlm7FXsvUjV7Dh785Yrq22+6psP/5PDPrp19KYcjZElL9VgTPdCrjuulu46qpruOaaK1tsP+3UE5k+/T986dAT6d17TZ6f+hg33jSasY8+yU477wfAGmv04sXpjzNmzKNpTt3aUSz5mOlHnk/zosWoSy1b3PFTGh6eyIIJ/1nWZ5UN+tLv9MOYdsg5NDUspMtaPZcbY8BZxzB/3LS0p965OdPNvn89Po45c+e12h4RdO/eHYDu3bsxZ848Ggue+Xn4YQdx/wOP8OGHi9t1rpau5kW5/z1VV4vquhAF2dU6x36Od669n6aGhQA0zm5Y1rba1oOpW7sXDY9OTm/CWdAc5W9V0OagK2lDST+W5H9+y/S7q65h8802ZuZrE5g04Z9878zzP/H/fMOOOoSbb76zSjO0dlNTw1ZjLmeHKdfQ8NhkFk58abnm+sH9qB/cly3uvJgt776EnkO3zzVIDDr/RF4fMaoKk+7kmprK36qgrKArqZ+k70p6BpiWHHd0kf7DJY2XNL65eWGFptp57bffUCZPnsbAQTuw4877ceUVF9GjR/dl7euuuw5bbbUZDzw4tnqTtPbR3MzUfc9k4o5fp/t2G7Hqpust16zaWuo36Mf0w3/My6f9kg0uO5Xa1Vejz4n7M+/hCXw0a3aVJt55RXNz2Vs5JNVKmijpHy20nSjpPUmTkq1k8b1oTVfScOAYoD9wC3AycGdEXFDsuIgYCYwE6NK1f8e+PSQFJx4/jJ//4rcAzJjxKq++OpPNNt2IZ8ZPAuDII77IHXfe94mSg2VH0/xFzH9yKj332p4PX3x92f6PZs1mwcSXiMYmlsx8l8Uz3qJ+g35033FTegzZnD4n7E9Nt3pq6rrQvHAxMy++oYo/RSdR+bLBd4DpwOqttN8cEd8qd7BSme5vkz5fjogfRcQUYKUPom31+sw32Xvv3QFYZ53ebLLJYF75v9eWtR897EsuLWRQlzVXp3b11QBQfVdW32NbFr/8xnJ95t7/NKt/dsukfw/qN+zHktffZsa3rmDSzqcwacg3eH3EKN67dawDbrmiufytBEkDgIOAqys1vVKrF/oCRwKXS1qXXLZbV6mTZ8UN1/+OPff4LL17r8mrr4znghGXUVeX+2Ma+afr+enFV/CXq3/FxAkPIYmzz72Y2bPnAjBo0AAGDOjLo4/9u5o/grWDuj5rsOGVp6OaGqipYc7dTzDvoWfp/4OjWTh5BvMefIaGsRPpuee2bDP2SqKpmdcvHEXj3AXVnnrn1oZMN/ltfnjerpHJb+pLXQGcBfQoMszhkvYA/gN8NyJmFj1n4QWdIpMbAAwjV27oBoyOiHNKHefygrXkid5Dqj0F64CGvHW7VnSMhecdXXbM6Tbib62eT9IXgAMj4jRJQ4HvR8QXCvqsBSyIiCWSTgGGRcTexc5Z9uqFiHgjIi6PiJ2AgwGvbTKzjqdy5YXdgIMlvQr8Ddhb0nI1noiYHRFLkq9XAzuWGrSsmyMkHdbC7ickrRMR75YzhplZKip0IS0izgbOBsjLdI/L7yOpb0TMSr4eTO6CW1Hl3pF2MvBZ4JHk+1DgWWADSSMi4voyxzEza1flLgX7tCSNAMZHxF3AtyUdDDQCc4ATSx1fbtDtAmweEe8kJ+0DXAcMAR4DHHTNrGNohzvNImIsMDb5fF7e/mXZcLnKDboDlwbcxLvJvjmSPm7LCc3M2lVG3hwxNrkb4+/J9yOSfd2A1h86YGaWtow8xPybwGHA7sn3UcBtkVtvtld7TMzM7NPIxDvSIiIkPQ58RO6OtKej3AW+ZmZp6uBBt9wH3hwFPE2urHAUME7SEe05MTOzT6W5ufytCsotL5wL7Lx0Ta6ktYGHgFvba2JmZp9KB890yw26NQU3QczGD0A3s44oI0H3fkkPADcl34cB97bPlMzMPr1o6tiv6yn3QtoPJB1O7l5kyD2JZ3T7TcvM7FPKSKZLRNwG3NaOczEzW2GdesmYpA9o+aHlIreSrLUnqZuZVUdnDroRUezBvWZmHU/HLumWX14wM+sMorFjR10HXTPLlo4dcx10zSxbOvWFNDOzTseZrplZepzpmpmlyZmumVl6orHaMyjOQdfMMqX0m9Wry0HXzLKlgwddP57RzDIlmsvfyiGpVtLE5D2RhW2rSLpZ0suSxklav9R4DrpmlimVDrrAd4DprbSdDMyNiI2AXwGXlhrMQdfMMiWaVPZWiqQBwEHA1a10OYTci3oh9yadfSQVHdhB18wypS2ZrqThksbnbcMLhrsCOIvWK8X9gZkAEdEINABrFZufL6SZWaZEc+kMdlnfiJHAyJbaJH0BeDcinpU0tDKzc6ZrZhlTwZrubsDBkl4F/gbsLemGgj5vAgMBJHUBepJ7h2SrHHTNLFMiVPZWfJw4OyIGRMT6wNHAwxFxXEG3u4ATks9HJH2K3ofs8oKZZUp73xwhaQQwPiLuAv4MXC/pZWAOueBclIOumWVKcxmrEtoqIsYCY5PP5+XtXwwc2ZaxHHTNLFPaciGtGhx0zSxTHHTNzFJU/DJW9TnomlmmONM1M0tRqaVg1eaga2aZ0tQOqxcqyUHXzDLFma6ZWYpc0zUzS5FXL5iZpciZrplZipqaO/ZzvBx0zSxTXF4wM0tRs1cvmJmlx0vGzMxStNKXF57oPaS9T2Gd0A5TLqv2FCyjXF4wM0uRVy+YmaWog1cXHHTNLFtcXjAzS5FXL5iZpaidXwa8whx0zSxTgo6d6Xbsy3xmZm3UGCp7K0ZSvaSnJU2WNE3SBS30OVHSe5ImJdvXSs3Pma6ZZUoFM90lwN4RsUBSHfC4pPsi4qmCfjdHxLfKHdRB18wypVI13YgIYEHytS7ZVnhFmssLZpYpgcreJA2XND5vG54/lqRaSZOAd4ExETGuhVMeLmmKpFslDSw1P2e6ZpYpbcl0I2IkMLJIexOwnaRewGhJW0XE1LwudwM3RcQSSacAo4C9i53Tma6ZZUoTKnsrV0TMAx4B9i/YPzsiliRfrwZ2LDWWg66ZZUqzyt+KkbR2kuEiaVVgX+CFgj59874eDEwvNT+XF8wsU5ort3qhLzBKUi25BPWWiPiHpBHA+Ii4C/i2pIOBRmAOcGKpQR10zSxTKvXAm4iYAmzfwv7z8j6fDZzdlnEddM0sU3wbsJlZiprVsW8DdtA1s0xpqvYESnDQNbNMKbUqodocdM0sUyq4eqFdOOiaWab4dT1mZilyecHMLEVeMmZmlqImZ7pmZulxpmtmliIHXTOzFHXwN7A76JpZtjjTNTNLkW8DNjNLkdfpmpmlyOUFM7MUOeiamaXIz14wM0uRa7pmZiny6gUzsxQ1d/ACQ021J2BmVknNbdiKkVQv6WlJkyVNk3RBC31WkXSzpJcljZO0fqn5OeiaWaZEG7YSlgB7R8S2wHbA/pJ2KehzMjA3IjYCfgVcWmpQB10zy5RKZbqRsyD5WpdshbH6EGBU8vlWYB+p+OuIHXTNLFMaFWVvkoZLGp+3Dc8fS1KtpEnAu8CYiBhXcLr+wEyAiGgEGoC1is3PF9LMLFPachktIkYCI4u0NwHbSeoFjJa0VURMXZH5OdM1s0ypVHkhX0TMAx4B9i9oehMYCCCpC9ATmF1sLAddM8uUZqLsrRhJaycZLpJWBfYFXijodhdwQvL5CODhiCg6sMsLZpYpFVyl2xcYJamWXIJ6S0T8Q9IIYHxE3AX8Gbhe0svAHODoUoM66JpZplTqgTcRMQXYvoX95+V9Xgwc2ZZxHXTNLFOaOvgdaQ66ZpYpfrSjmVmKwpmumVl6nOmuBLRKHVvcfhHqWoe61DDnnn/z5mU3f6Lfml/clQFnDiMiWPT8q8z45hXL2mq7r8o2Y3/NnAfG8dq5V6c5fWtH+x1+At1WW42amhpqa2u55S+/brHfc9Nf5LhTvscvLvgh++31PwBs8z8HsfHg9QHo22dtfvvzn6Q0686toz9lzEG3AmLJx0w/8nyaFy1GXWrZ4o6f0vDwRBZM+M+yPqts0Jd+px/GtEPOoalhIV3W6rncGAPOOob546alPXVLwV9+cwlr9OrZantTUxO/uuoadt15h+X2r7JKV24b9bv2nl7mdOyQ65sjKqZ50WIAVFeL6rpQuD56nWM/xzvX3k9Tw0IAGmc3LGtbbevB1K3di4ZHJ6c3Yeswbrz1LvYduhtrrtGr2lPJhEai7K0a2hR0Ja0jab2lW3tNqlOqqWGrMZezw5RraHhsMgsnvrRcc/3gftQP7ssWd17MlndfQs+hyfI/iUHnn8jrI0a1MKh1dpIY/t1zOeqk0/n7nfd+ov2d997nn489ybBDD/pE20cffcRRJ32bL3/9DP752JNpTDcTog3/Vw1llRckHQxcDvQj97SdQcB0YMtW+g8HhgP8sOd2fGm1DSoy2Q6tuZmp+55J7eqrscmf/5dVN12PD198fVmzamup36Af0w//MV37rsXmoy/iub3PoPfhezLv4Ql8NKvo7drWSV33+8vos3ZvZs+dx9fPOIcNBg1kp+22XtZ+6ZV/5LunnkRNzSfznwdvG0WftXsz881ZnPztH7Lx4PVZb0C/NKffKWXlQtqFwC7AQxGxvaS9gONa65z/5J5x/Q7r6CWWimqav4j5T06l517bLxd0P5o1mwUTXyIam1gy810Wz3iL+g360X3HTekxZHP6nLA/Nd3qqanrQvPCxcy8+IYq/hRWKX3W7g3AWmv0Yp89duW5519cLuhOe+ElfnD+JQDMbZjPv/79DLW1teyzx67Ljh3Yvy87b78NL7w0w0G3DFlZMvZxRMyWVCOpJiIekXRF6cNWDl3WXJ1obKRp/iJU35XV99iWWb8bvVyfufc/zVpf2p33b36YLmv2oH7Dfix5/W1mfOu/f4y9j9qLbttu6ICbEYs+XEw0N9Ot22os+nAxTz49gVO/+uXl+jxw67XLPp970eXsudtn2GePXWmY/wGr1q9C165dmTuvgYnPPc9Jxx6R8k/QOWUl050nqTvwGPBXSe8CC9tvWp1LXZ812PDK01FNDdTUMOfuJ5j30LP0/8HRLJw8g3kPPkPD2In03HNbthl7JdHUzOsXjqJx7oLSg1unNXvOXL5zzoUANDU2ceB+Q9l9l524efQ9AC3WcZd65bWZjPj5b1CNiObg5OOOYsMNBqUy786uqfhDvqpOJZ5CluskdQM+JHfh7Vhyz4y8ISLmlDp2ZSsvWHl2mHJZtadgHVBd78FFX3VTji8POrTsmHPja6NX+HxtVe7qhfMiojkiGiNiVET8Gvjf9pyYmdmn0dFXL5QbdPdtYd8BlZyImVkltMebIyqpaE1X0qnAacBgSVPymnoAT7TnxMzMPo3OfhvwjcB9wM+AH+bt/6Cceq6ZWdo6+pKxouWFiGiIiFcj4hhyL1/bOyJeA2okrQR3PJhZZ9MUUfZWDeXekXY+sBOwKXAN0BW4Adit/aZmZtZ2nb28sNSh5N4VNAEgIt6S1KPdZmVm9ill5eaIjyIiJAUsW7drZtbhdOqabp5bJP0R6CXp68BDwJ/ab1pmZp9OM1H2VoykgZIekfS8pGmSvtNCn6GSGiRNSrbzWhorX1mZbkRcJmlfYD65uu55ETGmnGPNzNJUzl22ZWoEzoyICUk59VlJYyLi+YJ+/4qIL5Q7aNlvjkiC7BhJvQE/h9DMOqRKvYI9ImYBs5LPH0iaDvQHCoNumxQtL0jaRdJYSbdL2l7SVGAq8I6k/VfkxGZm7aEt5QVJwyWNz9uGtzSmpPXJLSYY10LzZyVNlnSfpBafMZ6vVKb7W+Accg+4eRg4ICKekrQZcBNwf6kTmJmlqS3lhfxnf7cmecLibcAZETG/oHkCMCgiFkg6ELgD2LjYeKUupHWJiAcj4u/A2xHxVDLRF0ocZ2ZWFZW6kAYgqY5cwP1rRNxe2B4R8yNiQfL5XqAuKcG2qlTQzV/y9mHh+UrO2MwsZZV6ypgkAX8GpkfEL1vps27SD0mfIRdTi17zKlVe2FbSfEDAqslnku/1JY41M0tdBW/v3Q34CvCcpEnJvnOA9QAi4g/AEcCpkhrJJaZHR4n6RtGgGxG1KzprM7M0Veo24Ih4nFyCWazPb8ld+ypb2UvGzMw6g6w8e8HMrFOo4M0R7cJB18wyxZmumVmKOvoDbxx0zSxTmqJjP9zRQdfMMsU1XTOzFLmma2aWItd0zcxS1OzygplZepzpmpmlyKsXzMxS5PKCmVmKXF4wM0uRM10zsxQ50zUzS1FTNFV7CkU56JpZpvg2YDOzFPk2YDOzFDnTNTNLkVcvmJmlyKsXzMxS1NFvA66p9gTMzCopIsreipE0UNIjkp6XNE3Sd1roI0m/lvSypCmSdig1P2e6ZpYpFazpNgJnRsQEST2AZyWNiYjn8/ocAGycbEOA3yf/bZUzXTPLlEpluhExKyImJJ8/AKYD/Qu6HQJcFzlPAb0k9S02roOumWVKM1H2Jmm4pPF52/CWxpS0PrA9MK6gqT8wM+/7G3wyMC/H5QUzy5S2rNONiJHAyGJ9JHUHbgPOiIj5KzY7B10zy5hKrl6QVEcu4P41Im5vocubwMC87wOSfa1yecHMMqU5ouytGEkC/gxMj4hfttLtLuD4ZBXDLkBDRMwqNq4zXTPLlAreBrwb8BXgOUmTkn3nAOsl5/kDcC9wIPAysAj4aqlBHXTNLFMqdUdaRDwOqESfAL7ZlnEddM0sU/zAGzOzFHX0B96oo/+rkCWShidLVMyW8d+LlYtXL6SrxYXXttLz34uViIOumVmKHHTNzFLkoJsu1+2sJf57sRLxhTQzsxQ50zUzS5GDrplZihx0K0DSghU8vrekjyV9o1JzsuqT1CRpkqTJkiZI2rVE/16STktrflYdDrodw5HAU8Ax1Z6IVdSHEbFdRGwLnA38rET/XoCDbsY56FZQ8ni3X0iaKuk5ScOS/TWSrpL0gqQxku6VdETeoccAZwL9JQ2oyuStva0OzF36RdIPJD2TvMzwgmT3JcCGSXb8C0ndJf0zyZKfk3RIVWZuFeVnL1TWYcB2wLZAb+AZSY+Re0Tc+sAWwDrk3rX0F8i9cRToGxFPS7oFGAZcnv7UrR2smjwSsB7oC+wNIGk/ci8y/Ay5p1jdJWkP4IfAVhGxXdKvC3BoRMyX1Bt4StJd4SVHnZoz3craHbgpIpoi4h3gUWDnZP/fI6I5It4GHsk7ZhhwS/L5b7jEkCVLywubAfsD1yUPxt4v2SYCE4DNyAXhQgIuljQFeIjcu7f6pDJzazfOdKvvGGBdSccm3/tJ2jgiXqrmpKyyIuLfSba6Nrlg+rOI+GN+n+Tlh/mOTfrvGBEfS3qVXNZsnZgz3cr6FzBMUq2ktYE9gKeBJ4DDk9puH2AogKRNgO4R0T8i1o+I9cldbHG2mzGSNgNqgdnAA8BJyQsPkdRf0jrAB0CPvMN6Au8mAXcvYFDK07Z24Ey3skYDnwUmAwGcFRFvS7oN2Ad4ntzrmicADeSC6+iCMW4DbgZGpDVpazdLa7qQy25PiIgm4EFJmwP/zlUbWAAcFxEzJD0haSpwH3ApcLek54DxwAvp/whWab4NOCWSukfEAklrkct+d0vqu2a2EnGmm55/SOoFdAUudMA1Wzk50zUzS5EvpJmZpchB18wsRQ66ZmYpctA1M0uRg66ZWYr+H0ZqTDM50aSfAAAAAElFTkSuQmCC\n",
-            "text/plain": [
-              "<Figure size 432x288 with 2 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "lF3UWo-yVMwG"
-      },
-      "source": [
-        "## Loss function and grads"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "fY6qJidiVJMm",
-        "outputId": "74af27f1-3c9a-491a-c546-f42ceca96c72"
-      },
-      "source": [
-        "GRF_Amps_array=np.linspace(-7.05,-6.95,100)\n",
-        "GRF_Betas_array=np.linspace(1.5,2.5,100)\n",
-        "\n",
-        "GRF_losses_grid=np.zeros((100,100))\n",
-        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
-        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
-        "\n",
-        "for i in tqdm(range(100)):\n",
-        "  for j in range(100):\n",
-        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
-        "    GRF_Betas_grad_grid[i,j]=grad[1]"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "100%|██████████| 100/100 [08:24<00:00,  5.05s/it]\n"
-          ],
-          "name": "stderr"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 513
-        },
-        "id": "BQp3MRo5VQTK",
-        "outputId": "e7c8c447-1368-4e66-8ec0-ce7f787e4a07"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
-        "\n",
-        "y_labels=np.round(GRF_Amps_array,9)\n",
-        "x_labels=np.round(GRF_Betas_array,2)\n",
-        "\n",
-        "num_ticks = 10\n",
-        "# the index of the position of yticks\n",
-        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
-        "# the content of labels of these yticks\n",
-        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
-        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
-        "\n",
-        "\n",
-        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "ax[1].set_yticks([])\n",
-        "ax[2].set_yticks([])\n",
-        "\n",
-        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
-        "for i in range(3):\n",
-        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
-        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
-        "  ax[i].invert_yaxis()\n",
-        "\n",
-        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
-        "fig.tight_layout()\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1080x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "ZXMjTiXoVT0O",
-        "outputId": "ac8df346-a4e3-4496-e297-10c1ff5aea7a"
-      },
-      "source": [
-        "GRF_Amps_array=np.linspace(-10.,-6.,100)\n",
-        "GRF_Betas_array=np.linspace(1.,8.,100)\n",
-        "\n",
-        "GRF_losses_grid=np.zeros((100,100))\n",
-        "GRF_Amps_grad_grid=np.zeros((100,100))\n",
-        "GRF_Betas_grad_grid=np.zeros((100,100))\n",
-        "\n",
-        "for i in tqdm(range(100)):\n",
-        "  for j in range(100):\n",
-        "    GRF_losses_grid[i,j]=loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    grad=grad_loss_func([GRF_Amps_array[i],GRF_Betas_array[j]])\n",
-        "    GRF_Amps_grad_grid[i,j]=grad[0]\n",
-        "    GRF_Betas_grad_grid[i,j]=grad[1]"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "100%|██████████| 100/100 [08:23<00:00,  5.04s/it]\n"
-          ],
-          "name": "stderr"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "XGh262Uwb9gu"
-      },
-      "source": [
-        "history_hess_x_labels,history_hess_y_labels=reindex_history(np.load(Folder+'/Images/MSEhistory_trust-constr_hess.npy',allow_pickle=True))\n",
-        "history_jac_loose_x_labels,history_jac_loose_y_labels=reindex_history(np.load(Folder+'/Images/MSEhistory_trust-constr_jac_loose_bounds.npy',allow_pickle=True))\n",
-        "history_jac_tight_x_labels,history_jac_tight_y_labels=reindex_history(np.load(Folder+'/Images/MSEhistory_trust-constr_jac_tight_bounds.npy',allow_pickle=True))"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 513
-        },
-        "id": "kRSmFm1uVX3j",
-        "outputId": "828b7a2e-b21b-4769-f21b-e35621a5212b"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
-        "\n",
-        "y_labels=np.round(GRF_Amps_array,9)\n",
-        "x_labels=np.round(GRF_Betas_array,2)\n",
-        "\n",
-        "num_ticks = 10\n",
-        "# the index of the position of yticks\n",
-        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
-        "# the content of labels of these yticks\n",
-        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
-        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
-        "\n",
-        "#Loss\n",
-        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "#Fitting\n",
-        "#sns.lineplot(ax=ax[0],x=history_hess_x_labels,y=history_hess_y_labels,label='Hessian fitting',color='C0')\n",
-        "#ax[0].lines[0].set_linestyle((0, (1, 4)))\n",
-        "#sns.lineplot(ax=ax[0],x=history_jac_loose_x_labels,y=history_jac_loose_y_labels,label='Jac loose bounds fitting',color='black')\n",
-        "#ax[0].lines[1].set_linestyle((0, (3, 5, 1, 5)))\n",
-        "#sns.lineplot(ax=ax[0],x=history_jac_tight_x_labels,y=history_jac_tight_y_labels,label='Jac tight bounds fitting',color='C2')\n",
-        "#ax[0].lines[2].set_linestyle((0, (5, 5)))\n",
-        "#ax[0].legend(loc='lower left')\n",
-        "\n",
-        "#Grad Amp\n",
-        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "#Grad Beta\n",
-        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "ax[1].set_yticks([])\n",
-        "ax[2].set_yticks([])\n",
-        "\n",
-        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
-        "for i in range(3):\n",
-        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
-        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
-        "  ax[i].invert_yaxis()\n",
-        "  \n",
-        "\n",
-        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
-        "fig.tight_layout()\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1080x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "GncKODsRg777"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "kDgxu80Mkvgu"
-      },
-      "source": [
-        "### Possible correlation with physical characteristics of the GRF\n",
-        "\n",
-        "$A \\propto \\frac{\\sigma^2_{\\delta \\psi}}{\\sum_{k_x} \\sum_{k_y} k^{-\\beta}} \\propto \\frac{\\sigma^2_{\\delta \\alpha}}{\\sum_{k_x} \\sum_{k_y} k^{-\\beta+2}} \\propto \\frac{\\sigma^2_{\\delta \\kappa}}{\\sum_{k_x} \\sum_{k_y} k^{-\\beta+4}}$"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "rCw1_TWNeaq4"
-      },
-      "source": [
-        "k_grid,_=PowerBox_jax.get_k_grid_dx(npix,pix_scl)\n",
-        "k_grid[50,50]=np.inf"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "DUajk0GzfDFi",
-        "outputId": "9078fc2b-d1ff-4f40-d3fc-27fe5d028060"
-      },
-      "source": [
-        "variance_stat_sum=np.zeros(100)\n",
-        "deflection_stat_sum=np.zeros(100)\n",
-        "convergence_stat_sum=np.zeros(100)\n",
-        "\n",
-        "for i in tqdm(range(100)):\n",
-        "    variance_stat_sum[i]=np.power(k_grid,-GRF_Betas_array[i]).sum()\n",
-        "    deflection_stat_sum[i]=np.power(k_grid,-GRF_Betas_array[i]+2).sum()\n",
-        "    convergence_stat_sum[i]=np.power(k_grid,-GRF_Betas_array[i]+4).sum()\n",
-        "\n",
-        "deflection_stat_sum[deflection_stat_sum==np.inf]=np.nan\n",
-        "convergence_stat_sum[convergence_stat_sum==np.inf]=np.nan\n",
-        "\n",
-        "Variance_image=np.outer(np.power(10,GRF_Amps_array),variance_stat_sum)\n",
-        "Deflection_image=np.outer(np.power(10,GRF_Amps_array),deflection_stat_sum)\n",
-        "Convergence_image=np.outer(np.power(10,GRF_Amps_array),convergence_stat_sum)\n",
-        "\n",
-        "const_Var=np.log10((1e-10*variance_stat_sum[-1])/variance_stat_sum)\n",
-        "const_Def=np.log10((1e-10*deflection_stat_sum[-1])/deflection_stat_sum)\n",
-        "const_Conv=np.log10((1e-10*convergence_stat_sum[-1])/convergence_stat_sum)\n",
-        "\n",
-        "\n",
-        "const_x_Beta,const_Var_Amp=reindex_history(np.vstack((const_Var,GRF_Betas_array)).T)\n",
-        "const_x_Beta,const_Def_Amp=reindex_history(np.vstack((const_Def,GRF_Betas_array)).T)\n",
-        "const_x_Beta,const_Conv_Amp=reindex_history(np.vstack((const_Conv,GRF_Betas_array)).T)"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "100%|██████████| 100/100 [00:00<00:00, 506.53it/s]\n"
-          ],
-          "name": "stderr"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 575
-        },
-        "id": "OVmUg_Kuo-hV",
-        "outputId": "d36cb8fc-4884-4635-b7ae-7b42d14f862f"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,3,figsize=(15,7))\n",
-        "\n",
-        "y_labels=np.round(GRF_Amps_array,9)\n",
-        "x_labels=np.round(GRF_Betas_array,2)\n",
-        "\n",
-        "num_ticks = 10\n",
-        "# the index of the position of yticks\n",
-        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
-        "# the content of labels of these yticks\n",
-        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
-        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
-        "\n",
-        "#Loss\n",
-        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "\n",
-        "#Grad Amp\n",
-        "im=sns.heatmap(ax=ax[1],data=np.log10(np.abs(GRF_Amps_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "#Grad Beta\n",
-        "im=sns.heatmap(ax=ax[2],data=np.log10(np.abs(GRF_Betas_grad_grid)),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "ax[1].set_yticks([])\n",
-        "ax[2].set_yticks([])\n",
-        "\n",
-        "fig_names=[r'$log(Loss)$',r'$log(abs(\\frac{\\partial Loss}{\\partial log(Amp)}))$',r'$log(abs(\\frac{\\partial Loss}{\\partial Beta}))$']\n",
-        "for i in range(3):\n",
-        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
-        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
-        "  ax[i].invert_yaxis()\n",
-        "\n",
-        "  #Const levels\n",
-        "  sns.lineplot(ax=ax[i],x=const_x_Beta,y=const_Var_Amp,label=r'$\\sigma^2_{\\psi}=const$',color='C0')\n",
-        "  ax[i].lines[0].set_linestyle('solid')\n",
-        "  sns.lineplot(ax=ax[i],x=const_x_Beta,y=const_Def_Amp,label=r'$\\sigma^2_{\\alpha}=const$',color='black')\n",
-        "  ax[i].lines[1].set_linestyle('solid')\n",
-        "  sns.lineplot(ax=ax[i],x=const_x_Beta,y=const_Conv_Amp,label=r'$\\sigma^2_{\\kappa}=const$',color='C2')\n",
-        "  ax[i].lines[2].set_linestyle('solid')\n",
-        "  ax[i].legend(loc='lower left')\n",
-        "  \n",
-        " \n",
-        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
-        "fig.tight_layout()\n",
-        "fig.suptitle('Relation to physical characteristics of the GRF',y=1.1)\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1080x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 513
-        },
-        "id": "hmgyJrVpg9AZ",
-        "outputId": "002997bf-7a6c-494d-c540-756179a2c0f2"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,4,figsize=(15,7))\n",
-        "\n",
-        "y_labels=np.round(GRF_Amps_array,9)\n",
-        "x_labels=np.round(GRF_Betas_array,2)\n",
-        "\n",
-        "num_ticks = 10\n",
-        "# the index of the position of yticks\n",
-        "ticks = np.linspace(0, 100 - 1, num_ticks, dtype=np.int)\n",
-        "# the content of labels of these yticks\n",
-        "xticklabels = np.round([x_labels[idx] for idx in ticks],2)\n",
-        "yticklabels = np.round([y_labels[idx] for idx in ticks],2)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "#Loss\n",
-        "im=sns.heatmap(ax=ax[0],data=np.log10(GRF_losses_grid),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "#Const levels\n",
-        "sns.lineplot(ax=ax[0],x=const_x_Beta,y=const_Var_Amp,label=r'$\\sigma^2_{\\delta \\psi}=const$',color='C0')\n",
-        "ax[0].lines[0].set_linestyle((0, (1, 4)))\n",
-        "sns.lineplot(ax=ax[0],x=const_x_Beta,y=const_Def_Amp,label=r'$\\sigma^2_{\\delta \\alpha}=const$',color='black')\n",
-        "ax[0].lines[1].set_linestyle((0, (3, 5, 1, 5)))\n",
-        "sns.lineplot(ax=ax[0],x=const_x_Beta,y=const_Conv_Amp,label=r'$\\sigma^2_{\\delta \\kappa}=const$',color='C2')\n",
-        "ax[0].lines[2].set_linestyle((0, (5, 5)))\n",
-        "ax[0].legend(loc='lower left')\n",
-        "\n",
-        "#Variance\n",
-        "im=sns.heatmap(ax=ax[1],data=np.log10(Variance_image),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "#Deflection\n",
-        "im=sns.heatmap(ax=ax[2],data=np.log10(Deflection_image),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "#Convergence\n",
-        "im=sns.heatmap(ax=ax[3],data=np.log10(Convergence_image),xticklabels=xticklabels,yticklabels=yticklabels)\n",
-        "im.set_yticks(ticks)\n",
-        "im.set_xticks(ticks)\n",
-        "\n",
-        "ax[1].set_yticks([])\n",
-        "ax[2].set_yticks([])\n",
-        "ax[3].set_yticks([])\n",
-        "\n",
-        "fig_names=[r'$log(Loss)$','log(Variance)','log(Deflection)','log(Convergence)']\n",
-        "for i in range(4):\n",
-        "  ax[i].set_title(fig_names[i],fontsize=FS)\n",
-        "  ax[i].set_xlabel('Beta',fontsize=FS)\n",
-        "  ax[i].invert_yaxis()\n",
-        "  \n",
-        "\n",
-        "ax[0].set_ylabel(r'$log(Amp)$',fontsize=FS)\n",
-        "fig.tight_layout()\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1080x504 with 8 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "gmUHJzlmmQs3"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "iRI75po1mQ2R"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "det903ojmQ78"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "pOpk6BLaVgvD"
-      },
-      "source": [
-        "## Optimize"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "sBnEeyMeVh-r"
-      },
-      "source": [
-        "### with hessian"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "E_P2jxmIVc81",
-        "outputId": "160fb165-0e5a-441f-e133-bb38c87305d0"
-      },
-      "source": [
-        "Nfeval = 1\n",
-        "history=np.zeros((0,2))\n",
-        "init_guess=np.array([-1.,GRF_beta])\n",
-        "bounds=((-10., -0.), (1., 10.0))\n",
-        "\n",
-        "def callbackF(Xi,optimizer):\n",
-        "    global Nfeval\n",
-        "    global history\n",
-        "    loss=loss_func(Xi)\n",
-        "    grad=grad_loss_func(Xi)\n",
-        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
-        "    Nfeval += 1\n",
-        "    history=np.append(history,[Xi],axis=0)\n",
-        "\n",
-        "\n",
-        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,hess=hess_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "   1   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
-            "   2   -0.856200    4.945830    93802.966953    169.763134 -565.016849\n",
-            "   3   -5.868603    4.823393    2060.714368    10809.194234  5231.891315\n",
-            "   4   -5.963693    4.624140    765.942570    3926.522233  1850.125030\n",
-            "   5   -6.118314    4.552678    295.923386    1480.874943  693.268645\n",
-            "   6   -6.296659    4.512743    109.559732    556.830098  256.625525\n",
-            "   7   -6.493893    4.507251    39.090181    205.817236  94.455083\n",
-            "   8   -6.688996    4.499141    13.265328    74.782952  34.160232\n",
-            "   9   -6.846187    4.427419    4.337609    26.852622  12.029882\n",
-            "  10   -6.993091    4.361358    1.378231    9.337655  4.160843\n",
-            "  11   -7.121073    4.303814    0.494322    3.024544  1.398408\n",
-            "  12   -7.217084    4.258816    0.282365    0.821834  0.455768\n",
-            "  13   -7.268478    4.229778    0.250500    0.127337  0.163385\n",
-            "  14   -7.268478    4.229778    0.250500    0.127337  0.163385\n",
-            "  15   -7.268478    4.229778    0.250500    0.127337  0.163385\n",
-            "  16   -7.111189    3.796283    0.193141    0.077647  0.176693\n",
-            "  17   -7.111189    3.796283    0.193141    0.077647  0.176693\n",
-            "  18   -7.040381    3.484822    0.142384   -0.086890  0.152354\n",
-            "  19   -7.040381    3.484822    0.142384   -0.086890  0.152354\n",
-            "  20   -6.946291    3.284432    0.116975    0.561945  0.219962\n",
-            "  21   -6.955260    3.052993    0.076798    0.078366  0.123218\n",
-            "  22   -6.955260    3.052993    0.076798    0.078366  0.123218\n",
-            "  23   -6.955260    3.052993    0.076798    0.078366  0.123218\n",
-            "  24   -6.869221    2.260935    0.057663    1.264530 -0.108432\n",
-            "  25   -6.936373    2.265359    0.009101    0.253859  0.016325\n",
-            "  26   -6.957793    2.265176    0.006204    0.022189  0.042833\n",
-            "  27   -6.957793    2.265176    0.006204    0.022189  0.042833\n",
-            "  28   -6.987207    2.023089    0.000427    0.089673 -0.012133\n",
-            "  29   -6.995235    2.023894    0.000053    0.003518  0.003727\n",
-            "  30   -6.995235    2.023894    0.000053    0.003518  0.003727\n",
-            "  31   -6.999156    2.004130    0.000002    0.000702  0.000626\n",
-            "  32   -6.999156    2.004130    0.000002    0.000702  0.000626\n",
-            "  33   -6.999845    2.000799    0.000000    0.000046  0.000138\n",
-            "  34   -6.999845    2.000799    0.000000    0.000046  0.000138\n",
-            "  35   -6.999969    2.000159    0.000000    0.000007  0.000028\n",
-            "  36   -6.999969    2.000159    0.000000    0.000007  0.000028\n",
-            "  37   -6.999994    2.000032    0.000000    0.000001  0.000006\n",
-            "  38   -6.999994    2.000032    0.000000    0.000001  0.000006\n",
-            "  39   -6.999999    2.000006    0.000000    0.000000  0.000001\n",
-            "`gtol` termination condition is satisfied.\n",
-            "Number of iterations: 39, function evaluations: 31, CG iterations: 53, optimality: 7.98e-10, constraint violation: 0.00e+00, execution time: 4.5e+02 s.\n"
-          ],
-          "name": "stdout"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Nc2uJx_1VkGV"
-      },
-      "source": [
-        "np.save(Folder+'/Images/MSEhistory_trust-constr_hess.npy',history)\n",
-        "history_trust_constr_hess=np.load(Folder+'/Images/MSEhistory_trust-constr_hess.npy',allow_pickle=True)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Nq9ySFDpVtNY"
-      },
-      "source": [
-        "loss_history=np.array([loss_func(x) for x in history])\n",
-        "grads_history=np.array([grad_loss_func(x) for x in history])"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 597
-        },
-        "id": "Bi0GwbjHVwND",
-        "outputId": "1192a74c-fd5f-4cc1-c860-1ee51b784927"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
-        "\n",
-        "ax[0].plot(history[:,0],label='Fitting')\n",
-        "ax[0].set_title('Log(Amp)')\n",
-        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
-        "#ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
-        "#ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
-        "ax[0].legend()\n",
-        "\n",
-        "\n",
-        "\n",
-        "grads_history=np.array(grads_history)\n",
-        "loss_history=np.array(loss_history)\n",
-        "\n",
-        "ax[1].plot(np.abs(grads_history[:,0]))\n",
-        "ax[1].set_yscale('log')\n",
-        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
-        "\n",
-        "\n",
-        "ax[2].plot(history[:,1],label='Fitting')\n",
-        "ax[2].set_title('Beta')\n",
-        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
-        "ax[2].legend()\n",
-        "\n",
-        "ax[3].plot(np.abs(grads_history[:,1]))\n",
-        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
-        "ax[3].set_yscale('log')\n",
-        "\n",
-        "\n",
-        "\n",
-        "ax[4].plot(loss_history)\n",
-        "ax[4].set_yscale('log')\n",
-        "ax[4].set_title('Loss')\n",
-        "\n",
-        "fig.tight_layout()\n",
-        "fig.suptitle('weighted MAE loss',y=1.1)\n",
-        "\n",
-        "\n",
-        "\n",
-        "fig.add_subplot(111, frameon=False)\n",
-        "# hide tick and tick label of the big axis\n",
-        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
-        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1440x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "Lg18vRuvV1O1"
-      },
-      "source": [
-        "### only jacobian"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "NGYAzPx0VyYr",
-        "outputId": "8a736af9-8a14-4a97-a390-d4150eff871a"
-      },
-      "source": [
-        "Nfeval = 1\n",
-        "history=np.zeros((0,2))\n",
-        "init_guess=np.array([0.,GRF_beta])\n",
-        "bounds=((-10., -0.), (1., 6.0))\n",
-        "\n",
-        "def callbackF(Xi,optimizer):\n",
-        "    global Nfeval\n",
-        "    global history\n",
-        "    loss=loss_func(Xi)\n",
-        "    grad=grad_loss_func(Xi)\n",
-        "    print('{0:4d}   {1:3.6f}   {2: 3.6f}   {3: 3.6f}   {4: 3.6f} {5: 3.6f}'.format(Nfeval, Xi[0], Xi[1], loss,grad[0],grad[1]))\n",
-        "    Nfeval += 1\n",
-        "    history=np.append(history,[Xi],axis=0)\n",
-        "\n",
-        "\n",
-        "res=scipy_minimize(loss_func,GRF_init_guess,jac=grad_loss_func,bounds=bounds,method='trust-constr',options={'disp': True},callback=callbackF)"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "   1   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
-            "   2   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
-            "   3   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
-            "   4   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
-            "   5   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
-            "   6   -0.035741    4.949092    93898.525070    124.367351 -2654.024849\n",
-            "   7   -0.034966    4.965073    93898.349367    108.099959  2564.072969\n",
-            "   8   -0.034121    4.950125    93896.132090    120.124269 -2359.932024\n",
-            "   9   -0.044675    4.957270    93886.631516    100.305468  75.198587\n",
-            "  10   -0.095631    4.957070    93881.564259    98.091506  57.651556\n",
-            "  11   -1.323397    4.953307    93670.354084    521.297661  2346.429224\n",
-            "  12   -8.834048    4.924309    0.917340   -0.183921 -0.091864\n",
-            "  13   -8.830379    4.924320    0.916661   -0.185377 -0.092591\n",
-            "  14   -8.826692    4.924331    0.915974   -0.186850 -0.093327\n",
-            "  15   -8.822989    4.924342    0.915279   -0.188342 -0.094071\n",
-            "  16   -8.819268    4.924353    0.914574   -0.189851 -0.094825\n",
-            "  17   -8.815530    4.924364    0.913860   -0.191378 -0.095587\n",
-            "  18   -8.811773    4.924375    0.913137   -0.192924 -0.096359\n",
-            "  19   -8.807999    4.924387    0.912405   -0.194489 -0.097140\n",
-            "  20   -8.804206    4.924398    0.911663   -0.196074 -0.097931\n",
-            "  21   -8.800394    4.924409    0.910912   -0.197678 -0.098732\n",
-            "  22   -8.796564    4.924421    0.910150   -0.199302 -0.099542\n",
-            "  23   -8.792714    4.924432    0.909379   -0.200946 -0.100363\n",
-            "  24   -8.788844    4.924444    0.908597   -0.202611 -0.101194\n",
-            "  25   -8.784955    4.924455    0.907804   -0.204298 -0.102036\n",
-            "  26   -8.781045    4.924467    0.907001   -0.206005 -0.102888\n",
-            "  27   -8.777115    4.924478    0.906187   -0.207735 -0.103751\n",
-            "  28   -8.773164    4.924490    0.905362   -0.209488 -0.104626\n",
-            "  29   -8.769192    4.924502    0.904525   -0.211263 -0.105511\n",
-            "  30   -8.765199    4.924514    0.903676   -0.213061 -0.106409\n",
-            "  31   -8.761184    4.924526    0.902816   -0.214883 -0.107318\n",
-            "  32   -8.757146    4.924538    0.901943   -0.216729 -0.108239\n",
-            "  33   -8.753087    4.924550    0.901058   -0.218600 -0.109172\n",
-            "  34   -8.749004    4.924562    0.900161   -0.220496 -0.110118\n",
-            "  35   -8.744898    4.924574    0.899250   -0.222417 -0.111076\n",
-            "  36   -8.740769    4.924587    0.898326   -0.224365 -0.112048\n",
-            "  37   -8.736615    4.924599    0.897389   -0.226339 -0.113033\n",
-            "  38   -8.732438    4.924611    0.896438   -0.228341 -0.114031\n",
-            "  39   -8.728235    4.924624    0.895472   -0.230370 -0.115043\n",
-            "  40   -8.724008    4.924636    0.894493   -0.232427 -0.116069\n",
-            "  41   -8.719755    4.924649    0.893498   -0.234513 -0.117109\n",
-            "  42   -8.715476    4.924662    0.892489   -0.236629 -0.118164\n",
-            "  43   -8.711171    4.924675    0.891464   -0.238775 -0.119234\n",
-            "  44   -8.706839    4.924688    0.890423   -0.240951 -0.120319\n",
-            "  45   -8.702479    4.924701    0.889367   -0.243159 -0.121420\n",
-            "  46   -8.698093    4.924714    0.888293   -0.245398 -0.122536\n",
-            "  47   -8.693678    4.924727    0.887203   -0.247670 -0.123669\n",
-            "  48   -8.689234    4.924740    0.886096   -0.249975 -0.124818\n",
-            "  49   -8.684761    4.924753    0.884971   -0.252315 -0.125984\n",
-            "  50   -8.680259    4.924767    0.883828   -0.254689 -0.127167\n",
-            "  51   -8.675727    4.924780    0.882667   -0.257098 -0.128367\n",
-            "  52   -8.671164    4.924794    0.881486   -0.259544 -0.129586\n",
-            "  53   -8.666571    4.924808    0.880286   -0.262026 -0.130823\n",
-            "  54   -8.661945    4.924822    0.879067   -0.264546 -0.132078\n",
-            "  55   -8.657288    4.924836    0.877827   -0.267105 -0.133353\n",
-            "  56   -8.652598    4.924850    0.876566   -0.269703 -0.134647\n",
-            "  57   -8.647875    4.924864    0.875284   -0.272342 -0.135962\n",
-            "  58   -8.643118    4.924878    0.873980   -0.275021 -0.137296\n",
-            "  59   -8.638326    4.924892    0.872654   -0.277743 -0.138651\n",
-            "  60   -8.633500    4.924907    0.871305   -0.280507 -0.140028\n",
-            "  61   -8.628638    4.924921    0.869932   -0.283316 -0.141426\n",
-            "  62   -8.623740    4.924936    0.868536   -0.286169 -0.142847\n",
-            "  63   -8.618805    4.924951    0.867114   -0.289068 -0.144290\n",
-            "  64   -8.613833    4.924965    0.865667   -0.292015 -0.145756\n",
-            "  65   -8.608822    4.924980    0.864194   -0.295009 -0.147246\n",
-            "  66   -8.603773    4.924996    0.862695   -0.298052 -0.148760\n",
-            "  67   -8.598684    4.925011    0.861168   -0.301145 -0.150300\n",
-            "  68   -8.593555    4.925026    0.859613   -0.304289 -0.151864\n",
-            "  69   -8.588385    4.925042    0.858029   -0.307486 -0.153454\n",
-            "  70   -8.583173    4.925057    0.856416   -0.310737 -0.155071\n",
-            "  71   -8.577918    4.925073    0.854772   -0.314042 -0.156715\n",
-            "  72   -8.572621    4.925089    0.853097   -0.317404 -0.158386\n",
-            "  73   -8.567279    4.925105    0.851390   -0.320823 -0.160086\n",
-            "  74   -8.561893    4.925121    0.849650   -0.324301 -0.161814\n",
-            "  75   -8.556461    4.925137    0.847876   -0.327838 -0.163573\n",
-            "  76   -8.550982    4.925154    0.846067   -0.331438 -0.165361\n",
-            "  77   -8.545456    4.925170    0.844223   -0.335100 -0.167181\n",
-            "  78   -8.539882    4.925187    0.842342   -0.338826 -0.169032\n",
-            "  79   -8.534258    4.925204    0.840423   -0.342618 -0.170915\n",
-            "  80   -8.528585    4.925221    0.838465   -0.346478 -0.172832\n",
-            "  81   -8.522860    4.925238    0.836467   -0.350407 -0.174782\n",
-            "  82   -8.517083    4.925255    0.834429   -0.354406 -0.176768\n",
-            "  83   -8.511254    4.925273    0.832348   -0.358477 -0.178788\n",
-            "  84   -8.505370    4.925291    0.830223   -0.362622 -0.180845\n",
-            "  85   -8.499431    4.925308    0.828054   -0.366842 -0.182938\n",
-            "  86   -8.493435    4.925326    0.825838   -0.371140 -0.185070\n",
-            "  87   -8.487383    4.925345    0.823575   -0.375517 -0.187240\n",
-            "  88   -8.481272    4.925363    0.821263   -0.379974 -0.189450\n",
-            "  89   -8.475102    4.925381    0.818901   -0.384514 -0.191700\n",
-            "  90   -8.468870    4.925400    0.816487   -0.389139 -0.193992\n",
-            "  91   -8.462577    4.925419    0.814020   -0.393850 -0.196325\n",
-            "  92   -8.456221    4.925438    0.811497   -0.398649 -0.198702\n",
-            "  93   -8.449801    4.925457    0.808918   -0.403538 -0.201123\n",
-            "  94   -8.443314    4.925477    0.806281   -0.408520 -0.203588\n",
-            "  95   -8.436761    4.925497    0.803583   -0.413596 -0.206100\n",
-            "  96   -8.430140    4.925517    0.800823   -0.418768 -0.208658\n",
-            "  97   -8.423449    4.925537    0.797999   -0.424039 -0.211264\n",
-            "  98   -8.416687    4.925557    0.795110   -0.429410 -0.213919\n",
-            "  99   -8.409852    4.925578    0.792152   -0.434883 -0.216624\n",
-            " 100   -8.402944    4.925598    0.789123   -0.440461 -0.219379\n",
-            " 101   -8.395960    4.925619    0.786023   -0.446144 -0.222185\n",
-            " 102   -8.388899    4.925641    0.782848   -0.451937 -0.225044\n",
-            " 103   -8.381760    4.925662    0.779595   -0.457840 -0.227956\n",
-            " 104   -8.374541    4.925684    0.776263   -0.463855 -0.230922\n",
-            " 105   -8.367240    4.925706    0.772849   -0.469984 -0.233943\n",
-            " 106   -8.359856    4.925728    0.769351   -0.476229 -0.237019\n",
-            " 107   -8.352387    4.925751    0.765765   -0.482592 -0.240153\n",
-            " 108   -8.344832    4.925773    0.762089   -0.489075 -0.243343\n",
-            " 109   -8.337189    4.925796    0.758320   -0.495678 -0.246591\n",
-            " 110   -8.329456    4.925820    0.754455   -0.502404 -0.249897\n",
-            " 111   -8.321631    4.925843    0.750491   -0.509253 -0.253261\n",
-            " 112   -8.313713    4.925867    0.746425   -0.516227 -0.256685\n",
-            " 113   -8.305699    4.925891    0.742254   -0.523326 -0.260168\n",
-            " 114   -8.297589    4.925916    0.737974   -0.530551 -0.263710\n",
-            " 115   -8.289380    4.925941    0.733582   -0.537902 -0.267311\n",
-            " 116   -8.281071    4.925966    0.729074   -0.545380 -0.270970\n",
-            " 117   -8.272659    4.925991    0.724448   -0.552982 -0.274688\n",
-            " 118   -8.264144    4.926017    0.719699   -0.560709 -0.278463\n",
-            " 119   -8.255523    4.926043    0.714824   -0.568559 -0.282295\n",
-            " 120   -8.246794    4.926069    0.709819   -0.576530 -0.286181\n",
-            " 121   -8.237956    4.926096    0.704680   -0.584619 -0.290120\n",
-            " 122   -8.229007    4.926123    0.699404   -0.592822 -0.294111\n",
-            " 123   -8.219946    4.926150    0.693986   -0.601136 -0.298149\n",
-            " 124   -8.210770    4.926178    0.688424   -0.609553 -0.302232\n",
-            " 125   -8.201479    4.926206    0.682712   -0.618069 -0.306357\n",
-            " 126   -8.192071    4.926234    0.676848   -0.626675 -0.310518\n",
-            " 127   -8.182545    4.926263    0.670828   -0.635362 -0.314710\n",
-            " 128   -8.172900    4.926292    0.664648   -0.644119 -0.318928\n",
-            " 129   -8.163134    4.926322    0.658306   -0.652935 -0.323165\n",
-            " 130   -8.153248    4.926352    0.651797   -0.661793 -0.327412\n",
-            " 131   -8.143239    4.926382    0.645119   -0.670679 -0.331661\n",
-            " 132   -8.133109    4.926413    0.638269   -0.679573 -0.335901\n",
-            " 133   -8.122856    4.926444    0.631245   -0.688454 -0.340121\n",
-            " 134   -8.112481    4.926475    0.624046   -0.697296 -0.344306\n",
-            " 135   -8.101985    4.926507    0.616670   -0.706074 -0.348444\n",
-            " 136   -8.091368    4.926539    0.609116   -0.714756 -0.352515\n",
-            " 137   -8.080632    4.926571    0.601385   -0.723307 -0.356504\n",
-            " 138   -8.069779    4.926604    0.593477   -0.731689 -0.360387\n",
-            " 139   -8.058810    4.926637    0.585394   -0.739859 -0.364144\n",
-            " 140   -8.047730    4.926671    0.577140   -0.747770 -0.367748\n",
-            " 141   -8.036542    4.926705    0.568719   -0.755369 -0.371171\n",
-            " 142   -8.025250    4.926739    0.560135   -0.762600 -0.374384\n",
-            " 143   -8.013859    4.926773    0.551396   -0.769398 -0.377353\n",
-            " 144   -8.002377    4.926808    0.542512   -0.775698 -0.380042\n",
-            " 145   -7.990808    4.926843    0.533491   -0.781424 -0.382412\n",
-            " 146   -7.979163    4.926878    0.524347   -0.786498 -0.384423\n",
-            " 147   -7.967450    4.926914    0.515095   -0.790837 -0.386029\n",
-            " 148   -7.955679    4.926949    0.505751   -0.794351 -0.387185\n",
-            " 149   -7.943862    4.926985    0.496334   -0.796947 -0.387842\n",
-            " 150   -7.932013    4.927021    0.486867   -0.798527 -0.387949\n",
-            " 151   -7.920146    4.927057    0.477373   -0.798994 -0.387455\n",
-            " 152   -7.908276    4.927093    0.467878   -0.798245 -0.386307\n",
-            " 153   -7.908276    4.927093    0.467878   -0.798245 -0.386307\n",
-            " 154   -7.848408    4.927321    0.420584   -0.771958 -0.368458\n",
-            " 155   -7.790954    4.927540    0.377967   -0.699738 -0.326254\n",
-            " 156   -7.790954    4.927540    0.377967   -0.699738 -0.326254\n",
-            " 157   -7.747707    4.873301    0.365330   -0.675529 -0.304576\n",
-            " 158   -7.702004    4.842058    0.344823   -0.607186 -0.262349\n",
-            " 159   -7.702004    4.842058    0.344823   -0.607186 -0.262349\n",
-            " 160   -7.689707    4.844649    0.336946   -0.566972 -0.240863\n",
-            " 161   -7.523770    4.639694    0.295646   -0.324304 -0.087433\n",
-            " 162   -7.523770    4.639694    0.295646   -0.324304 -0.087433\n",
-            " 163   -7.497460    4.596363    0.290845   -0.299073 -0.069518\n",
-            " 164   -7.471506    4.551080    0.286141   -0.278315 -0.053724\n",
-            " 165   -7.445127    4.502834    0.281272   -0.260539 -0.039108\n",
-            " 166   -7.418223    4.451627    0.276118   -0.244945 -0.025218\n",
-            " 167   -7.390764    4.397522    0.270584   -0.230808 -0.011667\n",
-            " 168   -7.362676    4.340433    0.264566   -0.217403  0.001924\n",
-            " 169   -7.333884    4.280215    0.257962   -0.204001  0.015908\n",
-            " 170   -7.304319    4.216675    0.250661   -0.189832  0.030607\n",
-            " 171   -7.273930    4.149602    0.242550   -0.174036  0.046316\n",
-            " 172   -7.242692    4.078792    0.233516   -0.155613  0.063280\n",
-            " 173   -7.210634    4.004106    0.223464   -0.133386  0.081665\n",
-            " 174   -7.177870    3.925542    0.212335   -0.106008  0.101511\n",
-            " 175   -7.144635    3.843327    0.200143   -0.072064  0.122690\n",
-            " 176   -7.111326    3.758016    0.187002   -0.030269  0.144860\n",
-            " 177   -7.077665    3.671100    0.173264    0.029150  0.170001\n",
-            " 178   -7.046511    3.583248    0.159160    0.085919  0.191053\n",
-            " 179   -7.017504    3.496606    0.145148    0.149583  0.210275\n",
-            " 180   -7.017504    3.496606    0.145148    0.149583  0.210275\n",
-            " 181   -7.004204    3.172410    0.091821   -0.244363  0.112093\n",
-            " 182   -6.946453    2.529873    0.023259   -0.052009  0.082367\n",
-            " 183   -6.946453    2.529873    0.023259   -0.052009  0.082367\n",
-            " 184   -6.946453    2.529873    0.023259   -0.052009  0.082367\n",
-            " 185   -6.963564    2.426950    0.016870   -0.158539  0.078183\n",
-            " 186   -6.955020    2.424307    0.015632   -0.083556  0.073310\n",
-            " 187   -6.949597    2.321031    0.009054    0.045792  0.049340\n",
-            " 188   -6.962336    2.111678    0.002910    0.198519 -0.011404\n",
-            " 189   -6.975431    2.112659    0.001281    0.052680  0.011905\n",
-            " 190   -6.979861    2.112710    0.001150    0.006964  0.019095\n",
-            " 191   -6.979861    2.112710    0.001150    0.006964  0.019095\n",
-            " 192   -6.992903    2.033494    0.000107    0.009666  0.004379\n",
-            " 193   -6.993812    2.033407    0.000102    0.000528  0.005999\n",
-            " 194   -6.993812    2.033407    0.000102    0.000528  0.005999\n",
-            " 195   -6.999228    2.003365    0.000001    0.001429  0.000350\n",
-            " 196   -6.999351    2.003378    0.000001    0.000151  0.000591\n",
-            " 197   -6.999351    2.003378    0.000001    0.000151  0.000591\n",
-            " 198   -6.999869    2.000677    0.000000    0.000040  0.000117\n",
-            " 199   -6.999869    2.000677    0.000000    0.000040  0.000117\n",
-            " 200   -6.999973    2.000137    0.000000    0.000009  0.000024\n",
-            " 201   -6.999973    2.000137    0.000000    0.000009  0.000024\n",
-            " 202   -6.999995    2.000027    0.000000    0.000001  0.000005\n",
-            " 203   -6.999995    2.000027    0.000000    0.000001  0.000005\n",
-            " 204   -6.999999    2.000005    0.000000    0.000000  0.000001\n",
-            "`gtol` termination condition is satisfied.\n",
-            "Number of iterations: 204, function evaluations: 200, CG iterations: 378, optimality: 3.65e-09, constraint violation: 0.00e+00, execution time: 2.3e+01 s.\n"
-          ],
-          "name": "stdout"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "1RdHEuH8V3XG"
-      },
-      "source": [
-        "np.save(Folder+'/Images/MSEhistory_trust-constr_jac_tight_bounds.npy',history)\n",
-        "\n",
-        "#Bounds ((-10.,0.),(1.,10.))\n",
-        "#history_trust_constr_jac_loose_bounds=np.load(Folder+'/Images/MSEhistory_trust-constr_jac_loose_bounds.npy',allow_pickle=True)\n",
-        "\n",
-        "#Bounds ((-10.,0.),(1.,6.))\n",
-        "#history_trust_constr_jac_tight_bounds=np.load(Folder+'/Images/MSEhistory_trust-constr_jac_tight_bounds.npy',allow_pickle=True)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "mrPz5-9mWAT0"
-      },
-      "source": [
-        "loss_history=np.array([loss_func(x) for x in history])\n",
-        "grads_history=np.array([grad_loss_func(x) for x in history])"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 597
-        },
-        "id": "EEYKmRFsWDjC",
-        "outputId": "c4811155-b419-4f35-951c-e202b139eb85"
-      },
-      "source": [
-        "fig,ax=plt.subplots(1,5,figsize=(20,7))\n",
-        "\n",
-        "ax[0].plot(history[:,0],label='Fitting')\n",
-        "ax[0].set_title('Log(Amp)')\n",
-        "ax[0].hlines(GRF_LogAmp,0,len(history),color='red',label='G.T.')\n",
-        "#ax[0].hlines(bounds[0][0],0,len(history),color='black',label='Bounds')\n",
-        "#ax[0].hlines(bounds[0][1],0,len(history),color='black',label='Bounds')\n",
-        "ax[0].legend()\n",
-        "\n",
-        "\n",
-        "\n",
-        "grads_history=np.array(grads_history)\n",
-        "loss_history=np.array(loss_history)\n",
-        "\n",
-        "ax[1].plot(np.abs(grads_history[:,0]))\n",
-        "ax[1].set_yscale('log')\n",
-        "ax[1].set_title(r'$abs(\\frac{\\partial Loss}{\\partial log(Amp)})$')\n",
-        "\n",
-        "\n",
-        "ax[2].plot(history[:,1],label='Fitting')\n",
-        "ax[2].set_title('Beta')\n",
-        "ax[2].hlines(GRF_beta,0,len(history),color='red',label='G.T.')\n",
-        "ax[2].legend()\n",
-        "\n",
-        "ax[3].plot(np.abs(grads_history[:,1]))\n",
-        "ax[3].set_title(r'$abs(\\frac{\\partial Loss}{\\partial Beta})$')\n",
-        "ax[3].set_yscale('log')\n",
-        "\n",
-        "\n",
-        "\n",
-        "ax[4].plot(loss_history)\n",
-        "ax[4].set_yscale('log')\n",
-        "ax[4].set_title('Loss')\n",
-        "\n",
-        "fig.tight_layout()\n",
-        "fig.suptitle('weighted MAE loss',y=1.1)\n",
-        "\n",
-        "\n",
-        "\n",
-        "fig.add_subplot(111, frameon=False)\n",
-        "# hide tick and tick label of the big axis\n",
-        "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
-        "plt.xlabel('Fitting iterations',fontsize=FS)\n",
-        "\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 1440x504 with 6 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "bD5hAzxCJm3W"
-      },
-      "source": [
-        "# GRF unknown phase fitting"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "-dLW1NAGJw6Z"
-      },
-      "source": [
-        "## Phase averaging GRF Loss"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "h4hh_s2Sn8UZ"
-      },
-      "source": [
-        "### For loop requirements"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "PwNS1h4UYFin"
-      },
-      "source": [
-        "#Random phases of GRF in Fourier space\n",
-        "def get_phase_realisation(npix,seed):\n",
-        "  \"A random array which has Gaussian magnitudes and Hermitian symmetry\"\n",
-        "  key=jax.random.PRNGKey(seed)\n",
-        "  #uneven number\n",
-        "  n=npix + 1 if (npix%2==0) else npix\n",
-        "  #2d grid\n",
-        "  size=[n]*2\n",
-        "\n",
-        "  magnitude=jax.random.normal(key, shape=size)\n",
-        "  phase=2 * jnp.pi * jax.random.uniform(key,shape=size)\n",
-        "\n",
-        "  #Make hermitian (why?)\n",
-        "  magnitude=(magnitude+magnitude[::-1,::-1])/jnp.sqrt(2)\n",
-        "  phase=(phase-phase[::-1,::-1])/2 + jnp.pi\n",
-        "\n",
-        "  phase_realisation=magnitude * (jnp.cos(phase) + 1j * jnp.sin(phase))\n",
-        "\n",
-        "  if (npix%2==0):\n",
-        "    #why?\n",
-        "    phase_realisation=phase_realisation[:-1,:-1]\n",
-        "\n",
-        "  return phase_realisation"
-      ],
-      "execution_count": 107,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "8i6IQnyIZDlk"
-      },
-      "source": [
-        "#The very jaxified GRF. params=(Amplitude,Power_slope)\n",
-        "def get_jaxified_GRF(params,seed,npix,pix_scl):\n",
-        "\n",
-        "  logA,beta=params\n",
-        "  A=jnp.power(10.,logA)\n",
-        "\n",
-        "  k_grid,dx=PowerBox_jax.get_k_grid_dx(npix,pix_scl)\n",
-        "  k_grid[npix//2,npix//2]=1\n",
-        "  mask_center=np.ones_like(k_grid)\n",
-        "  mask_center[npix//2,npix//2]=0\n",
-        "\n",
-        "\n",
-        "  sqrt_power_array=jnp.sqrt(A)*jnp.power(k_grid,-beta/2.)*mask_center\n",
-        "  phase_realisation=get_phase_realisation(npix,seed)\n",
-        "\n",
-        "  Fourier_image=sqrt_power_array*phase_realisation\n",
-        "\n",
-        "  Config_image=(npix**2)*jnp.fft.ifftshift(jnp.fft.ifftn(Fourier_image))\n",
-        "\n",
-        "  Config_image=PowerBox_jax._adjust_phase(Config_image,npix, pix_scl)\n",
-        "\n",
-        "  return jnp.real(Config_image)\n",
-        "\n",
-        "def get_jaxified_GRF_pure(GRF_params,GRF_seed):\n",
-        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)"
-      ],
-      "execution_count": 153,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "TYLpty8nn7Js"
-      },
-      "source": [
-        "def jax_map(f, xs):\n",
-        "  scan_func = lambda _,x: (1,f(x))\n",
-        "  ys=jax.lax.scan(scan_func,0,xs)[1]\n",
-        "  return ys"
-      ],
-      "execution_count": 151,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "S3EluzXNobij"
-      },
-      "source": [
-        "def test(GRF_params,GRF_seeds,npix,pix_scl):\n",
-        "  func=lambda GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
-        "  GRFs=jax_map(func,GRF_seeds)\n",
-        "  return jnp.mean(GRFs)\n",
-        "\n",
-        "test_pure=purify_function(test,GRF_seeds,npix,pix_scl)"
-      ],
-      "execution_count": 154,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "MdZYiqE7oeQu",
-        "outputId": "b63f5b67-c963-432a-91d0-af819eda02b7"
-      },
-      "source": [
-        "test_pure(GRF_params)"
-      ],
-      "execution_count": 155,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(-1.28369537e-20, dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 155
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "_lwMC7B4of_d",
-        "outputId": "135adf9f-4714-4afe-a843-ae9f4788c7e5"
-      },
-      "source": [
-        "jax.grad(test_pure)(GRF_params)"
-      ],
-      "execution_count": 156,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([ 1.72057354e-20, -9.66918830e-22], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 156
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "qyfGkFOooAOp"
-      },
-      "source": [
-        "### Fitting with phase averaging"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "d75MIP5doDsK"
-      },
-      "source": [
-        "def GRF_Loss_phase_averaging(GRF_params,GRF_seeds,jax_map,unperturbed_image,\n",
-        "             get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
-        "             compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
-        "\n",
-        "  #Mapping GRF generator over seeds\n",
-        "  get_GRF=lambda GRF_seed: get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
-        "  GRFs=jax_map(get_GRF,GRF_seeds)\n",
-        "\n",
-        "  #Mapping image generator over seeds\n",
-        "  simulated_images=jax_map(simulate_perturbed_image_pure,GRFs)\n",
-        "\n",
-        "  resids=simulated_images-unperturbed_image\n",
-        "  #Map over residuals for each seed\n",
-        "  resid_spectra=jax_map(compute_radial_spectrum_pure,resids)\n",
-        "\n",
-        "  Spectra_Losses=jax_map(Spectra_Loss_pure,resid_spectra)\n",
-        "\n",
-        "  return jnp.mean(Spectra_Losses)"
-      ],
-      "execution_count": 195,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "-31eRQoLoDxA"
-      },
-      "source": [
-        "#Pick spectrum loss type (weighted MSE or weighted MAE)\n",
-        "Spectra_Loss_pure=purify_function(Spectra_Loss_MAE,resid_true_spectrum)\n",
-        "\n",
-        "Seeds_number=10\n",
-        "#Seeds that do not contain the true one\n",
-        "GRF_seeds=np.arange(GRF_seed+1,GRF_seed+11)\n",
-        "\n",
-        "GRF_Loss_args=(GRF_seeds,jax_map,unperturbed_image,get_jaxified_GRF_pure,simulate_perturbed_image_pure,compute_radial_spectrum_pure,Spectra_Loss_pure)\n",
-        "\n",
-        "#Precompile GRF_Loss \n",
-        "GRF_Loss_pure=purify_function(GRF_Loss_phase_averaging,*GRF_Loss_args)"
-      ],
-      "execution_count": 196,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "2UO8dImipvQr"
-      },
-      "source": [
-        "Loss=(GRF_Loss_pure)(GRF_params)\n",
-        "Grad_Loss=jax.grad(GRF_Loss_pure)(GRF_params)"
-      ],
-      "execution_count": 199,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "hQA2q9M5rKjX",
-        "outputId": "e8460148-f1c1-43e4-8058-cd4be3e9b6ab"
-      },
-      "source": [
-        "Loss"
-      ],
-      "execution_count": 200,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(0.23954485, dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 200
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "eP1gVIFUrSMb",
-        "outputId": "0250fe9a-bead-447f-d011-43c9f88a3790"
-      },
-      "source": [
-        "Grad_Loss"
-      ],
-      "execution_count": 201,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([-0.11464667, -0.07556207], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 201
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "EqPuE3H5sgmu"
-      },
-      "source": [
-        "### Fitting with kwargs fitting"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "XXmZsSQgoD6a"
-      },
-      "source": [
-        "def GRF_Loss_image_fitting(GRF_params,GRF_seed,\n",
-        "                            get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
-        "                            simulate_smooth_image_pure,model_loss_function,parameters,\\\n",
-        "                            args_guess,learning_rate,max_iter,\\\n",
-        "                            compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
-        "\n",
-        "  GRF=get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
-        "\n",
-        "  simulated_image=simulate_perturbed_image_pure(GRF)\n",
-        "\n",
-        "  model_loss_function_pure=purify_function(model_loss_function,simulated_image,parameters,simulate_smooth_image_pure)\n",
-        "  model_loss_grad=jax.grad(model_loss_function_pure)\n",
-        "\n",
-        "  args_fit=gradient_descent(model_loss_grad,args_guess,max_iter,learning_rate)\n",
-        "  unperturbed_image=simulate_smooth_image_pure(parameters.args2kwargs(args_fit))\n",
-        "\n",
-        "\n",
-        "  resid=simulated_image-unperturbed_image\n",
-        "  #Map over residuals for each seed\n",
-        "  resid_spectrum=compute_radial_spectrum_pure(resid)\n",
-        "\n",
-        "  return Spectra_Loss_pure(resid_spectrum)\n",
-        "\n",
-        "args_guess=parameters.kwargs2args(kwargs_data)\n",
-        "learning_rate=1\n",
-        "max_iter=100\n",
-        "GRF_Loss_image_fitting_args=(GRF_seed,\n",
-        "                            get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
-        "                            simulate_smooth_image_pure,model_loss_function,parameters,\\\n",
-        "                            args_guess,learning_rate,max_iter,\\\n",
-        "                            compute_radial_spectrum_pure,Spectra_Loss_pure)"
-      ],
-      "execution_count": 319,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "EDawMoTCI8ez"
-      },
-      "source": [
-        "GRF_Loss_image_fitting_pure=purify_function(GRF_Loss_image_fitting,*GRF_Loss_image_fitting_args)"
-      ],
-      "execution_count": 320,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "gtchu6gCJfTr",
-        "outputId": "b1834bae-dce1-4f58-cf79-a60c4764ac7d"
-      },
-      "source": [
-        "GRF_Loss_image_fitting_pure(GRF_params)"
-      ],
-      "execution_count": 321,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(103031.14678613, dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 321
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "39KS-8wQJ477",
-        "outputId": "df6773d1-6e67-4065-dfd9-22db4040cfdd"
-      },
-      "source": [
-        "jax.grad(GRF_Loss_image_fitting_pure)(GRF_params)"
-      ],
-      "execution_count": 322,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([14042.90651257, -3822.76900632], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 322
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "40fwmq-JI9t-"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "32PAha_9CQzS"
-      },
-      "source": [
-        "def gradient_descent(gradient_function,initial_guess,max_iter,learning_rate):\n",
-        "\n",
-        "  step_function= lambda _,X: X-learning_rate*gradient_function(X)\n",
-        "\n",
-        "  return jax.lax.fori_loop(0,max_iter,step_function,initial_guess)"
-      ],
-      "execution_count": 285,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "CifbBkZPCS6M"
-      },
-      "source": [
-        "simulate_smooth_image??"
-      ],
-      "execution_count": 286,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "rPiuM7_zCVUM"
-      },
-      "source": [
-        "parameters=get_parameters(kwargs_data,lens_mass_model_list,source_light_model_list)\n",
-        "def smooth_image_from_args(args,parameters,smooth_lens_image):\n",
-        "    kwargs=parameters.args2kwargs(args)\n",
-        "    return smooth_lens_image.model(**kwargs)\n",
-        "\n",
-        "def lens_model_loss_function(args_model,true_image,smooth_image_from_args):\n",
-        "    model_image=smooth_image_from_args(args_model,parameters,smooth_lens_image)\n",
-        "    return jnp.mean(jnp.power(true_image-model_image,2))\n",
-        "\n",
-        "lens_model_loss_function_pure=purify_function(lens_model_loss_function,perturbed_image,smooth_image_from_args)\n",
-        "lens_model_loss_function_grad=jax.grad(lens_model_loss_function_pure)"
-      ],
-      "execution_count": 298,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "fadZy3ZkEP_D"
-      },
-      "source": [
-        "def test_func(perturbed_image):\n",
-        "\n",
-        "  lens_model_loss_function_pure=purify_function(lens_model_loss_function,perturbed_image,smooth_image_from_args)\n",
-        "  lens_model_loss_function_grad=jax.grad(lens_model_loss_function_pure)\n",
-        "\n",
-        "  args_fit=gradient_descent(lens_model_loss_function_grad,args_data,100,1)\n",
-        "  return jnp.mean(args_fit)"
-      ],
-      "execution_count": 307,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "Kele9N8FE3fO",
-        "outputId": "f7207e47-76b9-4530-a4b3-535446ddfc00"
-      },
-      "source": [
-        "args_fit=test_func(perturbed_image)\n",
-        "args_fit"
-      ],
-      "execution_count": 308,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(1.06525433, dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 308
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "UrWOe7p9FZLr",
-        "outputId": "58e62f9f-6edc-414b-eafc-f719926a01dc"
-      },
-      "source": [
-        "image_grad=jax.grad(test_func)(perturbed_image)\n",
-        "image_grad"
-      ],
-      "execution_count": 309,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([[ 2.59096499e-06,  2.58111101e-06,  2.56222307e-06, ...,\n",
-              "              -8.61087507e-06, -7.92913190e-06, -7.43262708e-06],\n",
-              "             [ 2.75437164e-06,  2.74746110e-06,  2.73234056e-06, ...,\n",
-              "              -8.69403412e-06, -7.98733500e-06, -7.47313434e-06],\n",
-              "             [ 2.98069676e-06,  2.97804598e-06,  2.96840119e-06, ...,\n",
-              "              -8.78917836e-06, -8.04905331e-06, -7.51119510e-06],\n",
-              "             ...,\n",
-              "             [ 1.25822568e-07, -5.55769577e-08, -3.11478599e-07, ...,\n",
-              "               9.77560269e-06,  9.66589213e-06,  9.57398842e-06],\n",
-              "             [-1.54353252e-07, -3.38898415e-07, -5.98558393e-07, ...,\n",
-              "               8.94754429e-06,  8.86587527e-06,  8.79516182e-06],\n",
-              "             [-3.53569546e-07, -5.39963603e-07, -8.01745397e-07, ...,\n",
-              "               8.35417245e-06,  8.29189050e-06,  8.23586507e-06]],            dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 309
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 285
-        },
-        "id": "wodCIlloGCf5",
-        "outputId": "a98fed5d-d743-4180-ba7e-65ab988c1d77"
-      },
-      "source": [
-        "plt.imshow(image_grad)"
-      ],
-      "execution_count": 310,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "<matplotlib.image.AxesImage at 0x7f88db8b8e50>"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 310
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 432x288 with 1 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          }
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "L-dYxfZAD8rp",
-        "outputId": "9c2d5510-c8e3-4e6d-e078-abcc61251b39"
-      },
-      "source": [
-        "lens_model_loss_function_grad(args_data)"
-      ],
-      "execution_count": 300,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([ 6.81316887e-04, -1.41564855e-04, -1.82857258e-04,\n",
-              "             -1.92534138e-04,  5.46093013e-04,  3.84206441e-04,\n",
-              "              5.47206705e-04,  1.31644039e-05, -1.44542959e-05,\n",
-              "              1.85214443e-04,  9.72754374e-05, -3.12118343e-05,\n",
-              "              4.04593418e-04, -4.09870720e-04], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 300
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "VACfJ083Dpln",
-        "outputId": "f369fdf4-e3ad-446f-f668-009ff51d6bd5"
-      },
-      "source": [
-        "args_fit-args_data"
-      ],
-      "execution_count": 304,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([-0.01160592, -0.00032954, -0.00113101,  0.00300114,\n",
-              "             -0.00878816, -0.00072539, -0.00276271, -0.00088603,\n",
-              "              0.00280663, -0.01477706, -0.00750633,  0.00506102,\n",
-              "             -0.00503509,  0.00623905], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 304
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "FmREV3e3C_B7"
-      },
-      "source": [
-        "args_data=parameters.kwargs2args(kwargs_data)"
-      ],
-      "execution_count": 292,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "ErHLhjC2DDAq",
-        "outputId": "a15b8395-0297-46d8-f8aa-3641a2bee838"
-      },
-      "source": [
-        "args_data"
-      ],
-      "execution_count": 293,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([ 1.6 ,  0.15, -0.04,  0.  ,  0.  , -0.01,  0.03, 10.  ,\n",
-              "              1.2 ,  1.5 ,  0.07, -0.1 ,  0.4 ,  0.15], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 293
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "N5DJI4tyDDHQ"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Jjv0mq_ADDOe"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "bmUiBFrpDDWB"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "GTxXXS03DDeN"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "u4mwYAcqoD_k"
-      },
-      "source": [
-        "def minimize_function(function,grad_func,initial_guess,args,max_iter,learning_rate,jax_map):\n",
-        "\n",
-        "    history=np.zeros(learning_rate)\n",
-        "    history[0]=initial_guess\n",
-        "\n",
-        "    def step(arg,max_iter,learning_rate):\n",
-        "      i,X=arg\n",
-        "      new_X=X-learning_rate*grad_func(X)\n",
-        "      new_arg=(i+1,new_X)\n",
-        "\n",
-        "      Bool_end=((i+1)>=max_iter)\n",
-        "\n",
-        "      return_answer=lambda _,X: return new_X\n",
-        "      continue_cycle=lambda i,X: return step(new_arg,max_iter,learning_rate)\n",
-        "\n",
-        "      return jax.lax.cond(Bool_end,return_answer,continue_cycle,new_arg)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "xWOnrH6AoEEW"
-      },
-      "source": [
-        "def grad_descent(arg,grad_func,max_iter,learning_rate):\n",
-        "      i,X=arg\n",
-        "      new_X=X-learning_rate*grad_func(X)\n",
-        "\n",
-        "      Bool_end=((i+1)>=max_iter)\n",
-        "\n",
-        "      #Return optimization argument\n",
-        "      #return_answer=lambda _,new_X: new_X\n",
-        "      #Recursively continue descent\n",
-        "      #continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\n",
-        "      continue_cycle=lambda new_arg: grad_descent(new_arg,grad_func,max_iter,learning_rate)\n",
-        "      return_answer=lambda arg: arg\n",
-        "\n",
-        "      return jax.lax.cond(Bool_end,return_answer,continue_cycle,(i+1,new_X))"
-      ],
-      "execution_count": 238,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "frVLdzWhyZQ-"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": 258,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "lJeVBxP457EJ"
-      },
-      "source": [
-        "#### Gradient descent"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "fXB8444O3ypH"
-      },
-      "source": [
-        "def test_func(model,data):\n",
-        "  return jnp.abs(model-data)\n",
-        "\n",
-        "learning_rate=0.01\n",
-        "max_iter=100\n",
-        "\n",
-        "\n",
-        "def test(data):\n",
-        "\n",
-        "  test_func_pure=lambda model: test_func(model,10.)\n",
-        "  test_func_grad=jax.grad(test_func_pure)\n",
-        "\n",
-        "  step= lambda i,X: X-learning_rate*test_func_grad(X)\n",
-        "\n",
-        "  model=jax.lax.fori_loop(0,max_iter,step,data**2)\n",
-        "  return model"
-      ],
-      "execution_count": 271,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "LKkOOU3G9cUt"
-      },
-      "source": [
-        "def gradient_descent(gradient_function,initial_guess,max_iter,learning_rate):\n",
-        "\n",
-        "  step_function= lambda _,X: X-learning_rate*gradient_function(X)\n",
-        "\n",
-        "  return jax.lax.fori_loop(0,max_iter,step_function,initial_guess)"
-      ],
-      "execution_count": 275,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "1mkGf5MlB-xT"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": 284,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "LE-E8EBb_HxT"
-      },
-      "source": [
-        "test_func_pure=lambda model: test_func(model,10.)\n",
-        "test_func_grad=jax.grad(test_func_pure)"
-      ],
-      "execution_count": 276,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "_7sGEmjE_Mcg",
-        "outputId": "80ac14f1-3265-4bae-9380-1c16c04e6524"
-      },
-      "source": [
-        "gradient_descent_pure=lambda initial_guess: gradient_descent(test_func_grad,initial_guess,100,0.1)\n",
-        "jax.grad(gradient_descent_pure)(0.)"
-      ],
-      "execution_count": 280,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(1., dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 280
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "AH9J04tT4dJ3",
-        "outputId": "21ea5379-5c0e-4de4-e9ea-f8ddb2699c4f"
-      },
-      "source": [
-        "jax.grad(test)(2.)"
-      ],
-      "execution_count": 273,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(4., dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 273
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "Cc4vnI5Y54wt",
-        "outputId": "2ee81d2d-63fb-4008-c855-7fcc814bd843"
-      },
-      "source": [
-        "jax.grad(test)(3.)"
-      ],
-      "execution_count": 274,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(6., dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 274
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "9sW9lTHG4fmI",
-        "outputId": "1930ad18-d977-446c-a618-e1ec4fc5f54e"
-      },
-      "source": [
-        "test(2.)"
-      ],
-      "execution_count": 269,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(3., dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 269
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "oJVkTmAP4fsb"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "dLDY3odJ4fzU"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "5b9kWwxS3JBm"
-      },
-      "source": [
-        "\n",
-        "\n",
-        "def step(i,X):\n",
-        "  return X-learning_rate*test_func_grad(X)\n",
-        "\n",
-        "X=jax.lax.fori_loop(0,max_iter,step,0.)"
-      ],
-      "execution_count": 244,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "TwIiO55T3Y15",
-        "outputId": "d4be6e04-f863-45fd-daf6-97480c8b4b32"
-      },
-      "source": [
-        "X"
-      ],
-      "execution_count": 245,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(10., dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 245
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "uSzqgO3vyZWd",
-        "outputId": "622fcb28-f919-49cd-e8f8-3b518140e296"
-      },
-      "source": [
-        "test_func_grad(5.)"
-      ],
-      "execution_count": 232,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(-1., dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 232
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 494
-        },
-        "id": "R-Qed2D_yZcd",
-        "outputId": "e871725d-f1e1-43ea-8bd3-c425b5dcfd21"
-      },
-      "source": [
-        "init_guess=(0,0.)\n",
-        "grad_descent(init_guess,test_func_grad,10,0.1)"
-      ],
-      "execution_count": 239,
-      "outputs": [
-        {
-          "output_type": "error",
-          "ename": "RecursionError",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-239-c9fbb723c0c1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0minit_guess\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit_guess\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtest_func_grad\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mcond\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    725\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 726\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_cond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    727\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_cond\u001b[0;34m(pred, true_fun, false_fun, operand)\u001b[0m\n\u001b[1;32m    698\u001b[0m   jaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n\u001b[0;32m--> 699\u001b[0;31m       (true_fun, false_fun), ops_tree, ops_avals, 'cond')\n\u001b[0m\u001b[1;32m    700\u001b[0m   \u001b[0mtrue_jaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfalse_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjaxprs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxprs_with_common_consts\u001b[0;34m(funs, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36munzip3\u001b[0;34m(xyzs)\u001b[0m\n\u001b[1;32m     54\u001b[0m   \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxyzs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     92\u001b[0m       unzip3(_initial_style_open_jaxpr(fun, in_tree, in_avals, primitive_name)\n\u001b[0;32m---> 93\u001b[0;31m              for fun in funs)\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m      2\u001b[0m       \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m       \u001b[0mnew_X\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mgrad_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    796\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mgrad_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 797\u001b[0;31m     \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue_and_grad_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    798\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mvalue_and_grad_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    870\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 871\u001b[0;31m       \u001b[0mans\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvjp_py\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_vjp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_partial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mdyn_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_axes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreduce_axes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    872\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_vjp\u001b[0;34m(fun, has_aux, reduce_axes, *primals)\u001b[0m\n\u001b[1;32m   2136\u001b[0m     out_primal, out_vjp = ad.vjp(\n\u001b[0;32m-> 2137\u001b[0;31m         flat_fun, primals_flat, reduce_axes=reduce_axes)\n\u001b[0m\u001b[1;32m   2138\u001b[0m     \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mvjp\u001b[0;34m(traceable, primals, has_aux, reduce_axes)\u001b[0m\n\u001b[1;32m    114\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_aux\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m     \u001b[0mout_primals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinearize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraceable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mlinearize\u001b[0;34m(traceable, *primals, **kwargs)\u001b[0m\n\u001b[1;32m    101\u001b[0m   \u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjvpfun_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m   \u001b[0mout_primals_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tangents_pvals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_pvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr\u001b[0;34m(fun, pvals, instantiate)\u001b[0m\n\u001b[1;32m    504\u001b[0m     \u001b[0mfun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstantiate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 505\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_pvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    506\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-231-45f6ccfdccea>\u001b[0m in \u001b[0;36mtest_func\u001b[0;34m(arg)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m__sub__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    510\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__radd__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_radd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 511\u001b[0;31m   \u001b[0;32mdef\u001b[0m \u001b[0m__sub__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sub\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    512\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__rsub__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rsub\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36mdeferring_binary_op\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m   5923\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5924\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mbinary_op\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5925\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mdeferring_binary_op\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mcache_miss\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    407\u001b[0m         \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 408\u001b[0;31m         donated_invars=donated_invars, inline=inline)\n\u001b[0m\u001b[1;32m    409\u001b[0m     \u001b[0mout_pytree_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/ad.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    317\u001b[0m                   if update_params else params)\n\u001b[0;32m--> 318\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_jvp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mprimals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mnonzero_tangents\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mnew_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m     \u001b[0mprimal_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtangent_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree_def\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    194\u001b[0m       jaxpr, out_pvals, consts, env_tracers = self.partial_eval(\n\u001b[0;32m--> 195\u001b[0;31m           f, in_pvals, app, instantiate=False)\n\u001b[0m\u001b[1;32m    196\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap_primitive\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mpartial_eval\u001b[0;34m(self, f, pvals, app, instantiate)\u001b[0m\n\u001b[1;32m    302\u001b[0m     \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpartial_eval_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 303\u001b[0;31m     \u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0min_consts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    304\u001b[0m     \u001b[0mout_consts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msplit_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjaxpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstvars\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m   1071\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_sublevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1072\u001b[0;31m       \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1073\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'inline'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x1, x2)\u001b[0m\n\u001b[1;32m    424\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 425\u001b[0;31m     \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlax_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0m_promote_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumpy_fn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    426\u001b[0m   \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minline\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_args\u001b[0;34m(fun_name, *args)\u001b[0m\n\u001b[1;32m    326\u001b[0m   \u001b[0m_check_no_float0s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 327\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_promote_shapes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0m_promote_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    328\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_dtypes\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/lax.py\u001b[0m in \u001b[0;36m_convert_element_type\u001b[0;34m(operand, new_dtype, weak_type)\u001b[0m\n\u001b[1;32m    458\u001b[0m     return convert_element_type_p.bind(operand, new_dtype=new_dtype,\n\u001b[0;32m--> 459\u001b[0;31m                                        weak_type=new_weak_type)\n\u001b[0m\u001b[1;32m    460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m    264\u001b[0m     \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 265\u001b[0;31m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    266\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfull_lower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    142\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 143\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefault_process_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    144\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mdefault_process_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m    149\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    151\u001b[0m     \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minstantiate_const\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, *args, **params)\u001b[0m\n\u001b[1;32m    264\u001b[0m     \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 265\u001b[0;31m     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_primitive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    266\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiple_results\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfull_lower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mprocess_primitive\u001b[0;34m(self, primitive, tracers, params)\u001b[0m\n\u001b[1;32m   1063\u001b[0m     \u001b[0minvars\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1064\u001b[0;31m     \u001b[0moutvars\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmakevar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1065\u001b[0m     \u001b[0meqn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_jaxpr_eqn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutvars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msource_info\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36msafe_map\u001b[0;34m(f, *args)\u001b[0m\n\u001b[1;32m     40\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'length mismatch: {}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mmakevar\u001b[0;34m(self, tracer)\u001b[0m\n\u001b[1;32m   1040\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1041\u001b[0;31m     \u001b[0mvar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtracer_to_var\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnewvar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1042\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mvar\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mnewvar\u001b[0;34m(self, aval)\u001b[0m\n\u001b[1;32m    957\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mnewvar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 958\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgensym\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    959\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(aval)\u001b[0m\n\u001b[1;32m    195\u001b[0m   \u001b[0mcounter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 196\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0maval\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mVar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msuffix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    197\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, count, suffix, aval)\u001b[0m\n\u001b[1;32m    159\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msuffix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuffix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 160\u001b[0;31m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mraise_to_shaped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mraise_to_shaped\u001b[0;34m(aval, weak_type)\u001b[0m\n\u001b[1;32m   1225\u001b[0m     \u001b[0mhandler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mraise_to_shaped_mappings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtyp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1226\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mhandler\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mhandler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1227\u001b[0m   \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(aval, weak_type)\u001b[0m\n\u001b[1;32m   1234\u001b[0m   ShapedArray: lambda aval, weak_type: ShapedArray(\n\u001b[0;32m-> 1235\u001b[0;31m       aval.shape, aval.dtype, weak_type, aval.named_shape)\n\u001b[0m\u001b[1;32m   1236\u001b[0m }\n",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: RecursionError: maximum recursion depth exceeded\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mRecursionError\u001b[0m                            Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-239-c9fbb723c0c1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0minit_guess\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit_guess\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtest_func_grad\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcond\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBool_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreturn_answer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnew_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(new_arg)\u001b[0m\n\u001b[1;32m      9\u001b[0m       \u001b[0;31m#Recursively continue descent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m       \u001b[0;31m#continue_cycle=lambda i,new_X: grad_descent((i+1,new_X),grad_func,max_iter,learning_rate)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m       \u001b[0mcontinue_cycle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mnew_arg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m       \u001b[0mreturn_answer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-238-b8676301e072>\u001b[0m in \u001b[0;36mgrad_descent\u001b[0;34m(arg, grad_func, max_iter, learning_rate)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgrad_descent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m       \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m       \u001b[0mnew_X\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mgrad_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m       \u001b[0mBool_end\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m>=\u001b[0m\u001b[0mmax_iter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-231-45f6ccfdccea>\u001b[0m in \u001b[0;36mtest_func\u001b[0;34m(arg)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mtest_func_grad\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36mdeferring_binary_op\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m   5922\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_scalar_types\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0m_arraylike_types\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTracer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5923\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5924\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mbinary_op\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5925\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mdeferring_binary_op\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5926\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x1, x2)\u001b[0m\n\u001b[1;32m    423\u001b[0m     \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlax_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0m_promote_args_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumpy_fn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    424\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 425\u001b[0;31m     \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlax_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0m_promote_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumpy_fn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    426\u001b[0m   \u001b[0mfn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minline\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    427\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mlax_doc\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_args\u001b[0;34m(fun_name, *args)\u001b[0m\n\u001b[1;32m    325\u001b[0m   \u001b[0m_check_arraylike\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    326\u001b[0m   \u001b[0m_check_no_float0s\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 327\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0m_promote_shapes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0m_promote_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    328\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    329\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_promote_args_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m_promote_dtypes\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m    271\u001b[0m     \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lattice_result_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    275\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_promote_dtypes_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    271\u001b[0m     \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lattice_result_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    272\u001b[0m     \u001b[0mto_dtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanonicalize_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert_element_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mto_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweak_type\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    275\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_promote_dtypes_inexact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "1pyNFHoDyZh_"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "RQ7sOkt4oEI6"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "eRKAWvtfoBu-"
-      },
-      "source": [
-        "### Else"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "DpTFv0NqbDr2"
-      },
-      "source": [
-        "#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\n",
-        "g = lambda _,GRF_seed: (1,get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl))\n",
-        "GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])"
-      ],
-      "execution_count": 130,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "mrKvivQBbXIa"
-      },
-      "source": [
-        "def test(GRF_params,GRF_seeds,npix,pix_scl):\n",
-        "  g = lambda _,GRF_seed: (1,get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl))\n",
-        "  GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])\n",
-        "  return jnp.mean(GRFs)\n",
-        "\n",
-        "test_pure=purify_function(test,GRF_seeds,npix,pix_scl)"
-      ],
-      "execution_count": 137,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "scOH4r7hm2ZW"
-      },
-      "source": [
-        "def jax_map(f, xs):\n",
-        "  scan_func = lambda _,x: (1,f(x))\n",
-        "  ys=jax.lax.scan(scan_func,0,xs)[1]\n",
-        "  return ys"
-      ],
-      "execution_count": 144,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "4QhVro5unTCM"
-      },
-      "source": [
-        "func=lambda GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
-        "GRFs=jax_map(func,GRF_seeds)"
-      ],
-      "execution_count": 145,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Fjm38tG2nj5k"
-      },
-      "source": [
-        "def test(GRF_params,GRF_seeds,npix,pix_scl):\n",
-        "  func=lambda GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
-        "  GRFs=jax_map(func,GRF_seeds)\n",
-        "  return jnp.mean(GRFs)\n",
-        "\n",
-        "test_pure=purify_function(test,GRF_seeds,npix,pix_scl)"
-      ],
-      "execution_count": 148,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "iB3ksFlDnxkF",
-        "outputId": "ab046d4f-f136-4916-d45d-32851034fd0a"
-      },
-      "source": [
-        "test_pure(GRF_params)"
-      ],
-      "execution_count": 149,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(-1.28369537e-20, dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 149
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "MVRYBU4Qn22n",
-        "outputId": "ae4c995e-163d-4a4a-d672-113d35e48ab5"
-      },
-      "source": [
-        "jax.grad(test_pure)(GRF_params)"
-      ],
-      "execution_count": 150,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([ 1.72057354e-20, -9.66918830e-22], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 150
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "xfa7IKSRb-S7",
-        "outputId": "ae12cebd-366c-473a-f35f-c0117f6dc916"
-      },
-      "source": [
-        "test_pure(GRF_params)"
-      ],
-      "execution_count": 138,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(-1.28369537e-20, dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 138
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "5pQNIBT9cAz_",
-        "outputId": "8866c1c0-ba91-4745-8b42-09e0d1e6521d"
-      },
-      "source": [
-        "jax.grad(test_pure)(GRF_params)"
-      ],
-      "execution_count": 141,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([ 1.72057354e-20, -9.66918830e-22], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 141
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "cc-x2boccIpg"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "TQ836WRCmoH2"
-      },
-      "source": [
-        "def GRF_Loss_phase_averaging(GRF_params,GRF_seeds,unperturbed_image,\n",
-        "             get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
-        "             compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
-        "\n",
-        "\n",
-        "  GRFs=get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
-        "\n",
-        "  simulated_image=simulate_perturbed_image_pure(GRF)\n",
-        "\n",
-        "  resid=simulated_image-unperturbed_image\n",
-        "  resid_spectrum=compute_radial_spectrum_pure(resid)\n",
-        "\n",
-        "  return Spectra_Loss_pure(resid_spectrum)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "7aTuADSOmoMF"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "tXOmcDw8moQQ"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "qveWV_eKmoUi"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "WJRB8qr6moZC"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "dXbbfmrYboHN",
-        "outputId": "1d6b50b3-b954-4e40-a270-0e199b288faa"
-      },
-      "source": [
-        "test(GRF_params,GRF_seeds,npix,pix_scl)"
-      ],
-      "execution_count": 136,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray(-2.07125983e-19, dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 136
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "ENgEPaBibJ-z",
-        "outputId": "a9d0b50f-a91c-472d-8641-d98f90095fc4"
-      },
-      "source": [
-        "GRFs.shape"
-      ],
-      "execution_count": 132,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "(8, 100, 100)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 132
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Dk5XPYDzbPEn"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "PIOo6qilbPIl"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "_2AW63TKatXN",
-        "outputId": "0c62efe7-5e6b-441a-8c6f-e94c1860e608"
-      },
-      "source": [
-        "test(GRF_params,GRF_seed)"
-      ],
-      "execution_count": 127,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([[ 3.25806937e-04, -1.39600163e-02, -2.37375768e-02, ...,\n",
-              "              -8.88541266e-03, -3.23081929e-03, -2.46492310e-03],\n",
-              "             [-7.24474457e-03, -1.77732719e-02, -2.79357125e-02, ...,\n",
-              "               1.05281659e-03, -4.40623246e-03, -2.26561027e-04],\n",
-              "             [-1.01756208e-02, -1.89674044e-02, -4.25634981e-02, ...,\n",
-              "              -1.32873739e-03, -6.52506532e-03,  5.27138495e-03],\n",
-              "             ...,\n",
-              "             [-9.65185178e-03, -6.77607686e-03, -1.10149004e-02, ...,\n",
-              "               1.62030230e-05, -7.61569564e-03, -1.78757703e-02],\n",
-              "             [-1.67147186e-03, -5.47283177e-03, -1.16820204e-02, ...,\n",
-              "               1.46123272e-02, -1.07998702e-02, -1.30477015e-02],\n",
-              "             [ 6.94097951e-03,  4.94321425e-03, -1.39605537e-02, ...,\n",
-              "               1.31260745e-02,  8.41794504e-03,  8.53962036e-03]],            dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 127
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 562
-        },
-        "id": "u-N4LsOaaXyg",
-        "outputId": "1a5f4cf7-68ed-4b2f-d484-c968750fcbc3"
-      },
-      "source": [
-        "vv = lambda GRF_seed, GRF_params: test(GRF_params,GRF_seed)\n",
-        "mv = jax.vmap(vv, (0, None), 0)\n",
-        "matrix=np.outer([5,6],GRF_seed)\n",
-        "mv(matrix,GRF_params)"
-      ],
-      "execution_count": 128,
-      "outputs": [
-        {
-          "output_type": "error",
-          "ename": "TypeError",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mbatched_fun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1286\u001b[0m         \u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mflatten_axes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"vmap out_axes\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_axes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1287\u001b[0;31m     ).call_wrapped(*args_flat)\n\u001b[0m\u001b[1;32m   1288\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mtree_unflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_flat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_seed, GRF_params)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mcache_miss\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    407\u001b[0m         \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mflat_fun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 408\u001b[0;31m         donated_invars=donated_invars, inline=inline)\n\u001b[0m\u001b[1;32m    409\u001b[0m     \u001b[0mout_pytree_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/batching.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, call_primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    158\u001b[0m       \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch_subtrace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 159\u001b[0;31m       \u001b[0mvals_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_primitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    160\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mBatchTracer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvals_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdims_out\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(self, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1613\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1614\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mcall_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1615\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mcall_bind\u001b[0;34m(primitive, fun, *args, **params)\u001b[0m\n\u001b[1;32m   1604\u001b[0m   \u001b[0mtracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1605\u001b[0;31m   \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtop_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1606\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_lower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_todos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_trace_todo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(self, trace, fun, tracers, params)\u001b[0m\n\u001b[1;32m   1616\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1617\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1618\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36mprocess_call\u001b[0;34m(self, primitive, f, tracers, params)\u001b[0m\n\u001b[1;32m    612\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 613\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mprimitive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mtracers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    614\u001b[0m   \u001b[0mprocess_map\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocess_call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_call_impl\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m    619\u001b[0m   compiled_fun = _xla_callable(fun, device, backend, name, donated_invars,\n\u001b[0;32m--> 620\u001b[0;31m                                *unsafe_map(arg_spec, args))\n\u001b[0m\u001b[1;32m    621\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mmemoized_fun\u001b[0;34m(fun, *args)\u001b[0m\n\u001b[1;32m    261\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 262\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    263\u001b[0m       \u001b[0mcache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mans\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/xla.py\u001b[0m in \u001b[0;36m_xla_callable\u001b[0;34m(fun, device, backend, name, donated_invars, *arg_specs)\u001b[0m\n\u001b[1;32m    696\u001b[0m   jaxpr, out_avals, consts = pe.trace_to_jaxpr_final(\n\u001b[0;32m--> 697\u001b[0;31m       fun, abstract_args, pe.debug_info_final(fun, \"jit\"))\n\u001b[0m\u001b[1;32m    698\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTracer\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_final\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1284\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_sublevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1285\u001b[0;31m       \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1286\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_params, GRF_seed)\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;31m#test=purify_function(get_jaxified_GRF,GRF_seed,npix,pix_scl)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m     13\u001b[0m   \u001b[0msqrt_power_array\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_grid\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mbeta\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mmask_center\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-107-4e83d035625d>\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m      3\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m   \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPRNGKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m   \u001b[0;31m#uneven number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/random.py\u001b[0m in \u001b[0;36mPRNGKey\u001b[0;34m(seed)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"PRNGKey seed must be a scalar; got {seed!r}.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missubdtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minteger\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: TypeError: PRNGKey seed must be a scalar; got Traced<ShapedArray(int64[1])>with<BatchTrace(level=1/1)>\n  with val = Traced<ShapedArray(int64[2,1])>with<DynamicJaxprTrace(level=0/1)>\n       batch_dim = 0.\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mmv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-128-7c2681a860c0>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_seed, GRF_params)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mouter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mmv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(GRF_params, GRF_seed)\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;31m#test=purify_function(get_jaxified_GRF,GRF_seed,npix,pix_scl)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-126-e65c80ebd36a>\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m   \u001b[0msqrt_power_array\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_grid\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mbeta\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mmask_center\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m   \u001b[0mFourier_image\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msqrt_power_array\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mphase_realisation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-107-4e83d035625d>\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m   \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPRNGKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m   \u001b[0;31m#uneven number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m   \u001b[0mn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnpix\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mnpix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/random.py\u001b[0m in \u001b[0;36mPRNGKey\u001b[0;34m(seed)\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0mseed_arr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"PRNGKey seed must be a scalar; got {seed!r}.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missubdtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minteger\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"PRNGKey seed must be an integer; got {seed!r}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mTypeError\u001b[0m: PRNGKey seed must be a scalar; got Traced<ShapedArray(int64[1])>with<BatchTrace(level=1/1)>\n  with val = Traced<ShapedArray(int64[2,1])>with<DynamicJaxprTrace(level=0/1)>\n       batch_dim = 0."
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "b2CUB3OSaX2P"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "yBQ2qUpKaX5s"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "uKeoLcUrZeFk",
-        "outputId": "908dfa35-779b-4ce4-d8a6-4cc69ae3b85b"
-      },
-      "source": [
-        "jax.grad(jax.jit(lambda GRF_params: np.std(test(GRF_params))))(GRF_params)"
-      ],
-      "execution_count": 124,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([0.01728465, 0.00479345], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 124
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "RaLjUeugX4z4"
-      },
-      "source": [
-        "key=random.PRNGKey(0)\n",
-        "jax.random.normal()"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 164
-        },
-        "id": "BTkoFv62XztY",
-        "outputId": "df120cc1-4935-4b16-9d94-a8c4ef7c51fd"
-      },
-      "source": [
-        "jnp.random.normal(size=(1,2))"
-      ],
-      "execution_count": 100,
-      "outputs": [
-        {
-          "output_type": "error",
-          "ename": "AttributeError",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-100-2db52f4c04f6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;31mAttributeError\u001b[0m: module 'jax.numpy' has no attribute 'random'"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "6TMBZ0ALVbd7"
-      },
-      "source": [
-        "@jax.partial(jax.jit,static_argnums=(1,))\n",
-        "def get_jaxified_GRF_pure(GRF_params,GRF_seed):\n",
-        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)"
-      ],
-      "execution_count": 99,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "gqn2oPLGTuzO"
-      },
-      "source": [
-        "vv = lambda x, y: print(x,y)\n",
-        "mv = jax.vmap(vv, (0, None), 0)\n",
-        "mm = jax.vmap(mv, (None, 1), 1)"
-      ],
-      "execution_count": 96,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "HGXNzadJVJwI",
-        "outputId": "ed1109ae-49d2-48d4-aa53-1314e54e01df"
-      },
-      "source": [
-        "vv(GRF_seed,GRF_params)"
-      ],
-      "execution_count": 97,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "1 [-7.  2.]\n"
-          ],
-          "name": "stdout"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "azV7s-WJVZuM"
-      },
-      "source": [
-        "get_jaxified_GRF_pure??"
-      ],
-      "execution_count": 89,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "01PF9zD9VN_V",
-        "outputId": "2caef2fd-7974-4baf-f40f-ede5fe3bcd2f"
-      },
-      "source": [
-        "matrix=np.outer([5,6],GRF_seed)\n",
-        "mv(matrix,GRF_params)"
-      ],
-      "execution_count": 98,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "Traced<ShapedArray(int64[1])>with<BatchTrace(level=1/0)>\n",
-            "  with val = array([[5],\n",
-            "                    [6]])\n",
-            "       batch_dim = 0 [-7.  2.]\n"
-          ],
-          "name": "stdout"
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "e9Nqu-Z6Tu8H",
-        "outputId": "9e99aa6f-2a8a-49e2-941a-2f4d01a7f37b"
-      },
-      "source": [
-        "arr1=1\n",
-        "matrix=np.outer([5,6],arr1)\n",
-        "arr2=np.array([2,3,4])\n",
-        "vv(arr1,arr2)"
-      ],
-      "execution_count": 83,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "array([2, 3, 4])"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 83
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "I_P9ZWosUWuB",
-        "outputId": "a4d4a557-4839-43ec-fb05-67110d319346"
-      },
-      "source": [
-        "mv(matrix,arr2)"
-      ],
-      "execution_count": 84,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([[10, 15, 20],\n",
-              "             [12, 18, 24]], dtype=int64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 84
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "c-INyoeRTvAX"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "ogS4UzLdKIBQ"
-      },
-      "source": [
-        "simulate_perturbed_image_pure=purify_function(simulate_perturbed_image,kwargs_data,perturbed_lens_image,x_coords,y_coords)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "3efGrwhgPddT"
-      },
-      "source": [
-        "def get_jaxified_GRF_traced(GRF_params,GRF_seed):\n",
-        "  return get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)"
-      ],
-      "execution_count": 64,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "se85H3n9ResR",
-        "outputId": "154bdc67-c8d7-4272-dac5-b0975342c32d"
-      },
-      "source": [
-        "GRF_params=jnp.array([GRF_LogAmp,GRF_beta])\n",
-        "get_jaxified_GRF_pure(GRF_params,GRF_seed)"
-      ],
-      "execution_count": 59,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([[-0.01243255, -0.00829889,  0.00402387, ..., -0.00904885,\n",
-              "              -0.00604214, -0.00302176],\n",
-              "             [-0.00226499, -0.01453809, -0.0219767 , ...,  0.01113688,\n",
-              "               0.00434794,  0.00886271],\n",
-              "             [ 0.00602436, -0.01029537, -0.01696046, ...,  0.01601606,\n",
-              "               0.01204917,  0.00664493],\n",
-              "             ...,\n",
-              "             [ 0.01468725,  0.00566183,  0.01739841, ..., -0.0066037 ,\n",
-              "               0.00138568,  0.01062642],\n",
-              "             [-0.00426157, -0.00196087, -0.01263381, ..., -0.00767667,\n",
-              "              -0.00317466, -0.00206083],\n",
-              "             [-0.01814698,  0.00783441, -0.00736378, ..., -0.01183791,\n",
-              "              -0.02245846, -0.02427405]], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 59
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "3yHBnp8jSAt9"
-      },
-      "source": [
-        "get_jaxified_GRF_pure??"
-      ],
-      "execution_count": 63,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "yWNN4_ZnOWWr"
-      },
-      "source": [
-        "#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\n",
-        "g = lambda _,GRF_seed: get_jaxified_GRF(GRF_params,GRF_seed,npix,pix_scl)\n",
-        "GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])"
-      ],
-      "execution_count": 69,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 613
-        },
-        "id": "bLRekLZwQfk6",
-        "outputId": "e8d849a7-50a1-4922-df25-15c812a0a7cc"
-      },
-      "source": [
-        "GRFs=(jax.lax.scan(g,0,GRF_seeds)[1])"
-      ],
-      "execution_count": 70,
-      "outputs": [
-        {
-          "output_type": "error",
-          "ename": "ConcretizationTypeError",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-70-b1b57523e422>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGRFs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seeds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1287\u001b[0m   \u001b[0;31m# necessary, a second time with modified init values.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1288\u001b[0;31m   \u001b[0minit_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mrest\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_create_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1289\u001b[0m   \u001b[0mnew_init_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchanged\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_promote_weak_typed_inputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minit_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcarry_avals_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_create_jaxpr\u001b[0;34m(init)\u001b[0m\n\u001b[1;32m   1274\u001b[0m     jaxpr, consts, out_tree = _initial_style_jaxpr(\n\u001b[0;32m-> 1275\u001b[0;31m         f, in_tree, carry_avals + x_avals, \"scan\")\n\u001b[0m\u001b[1;32m   1276\u001b[0m     \u001b[0mout_tree_children\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchildren\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     76\u001b[0m   jaxpr, consts, out_tree = _initial_style_open_jaxpr(\n\u001b[0;32m---> 77\u001b[0;31m       fun, in_tree, in_avals, primitive_name)\n\u001b[0m\u001b[1;32m     78\u001b[0m   \u001b[0mclosed_jaxpr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mClosedJaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert_constvars_jaxpr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjaxpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    185\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trace_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/util.py\u001b[0m in \u001b[0;36mcached\u001b[0;34m(_, *args, **kwargs)\u001b[0m\n\u001b[1;32m    178\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 179\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m_initial_style_open_jaxpr\u001b[0;34m(fun, in_tree, in_avals, primitive_name)\u001b[0m\n\u001b[1;32m     69\u001b[0m   \u001b[0mdebug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprimitive_name\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m\"<unknown>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m   \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_to_jaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped_fun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_tree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_jaxpr_dynamic\u001b[0;34m(fun, in_avals, debug_info)\u001b[0m\n\u001b[1;32m   1252\u001b[0m     \u001b[0mmain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjaxpr_stack\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1253\u001b[0;31m     \u001b[0mjaxpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout_avals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrace_to_subjaxpr_dynamic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1254\u001b[0m     \u001b[0;32mdel\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/interpreters/partial_eval.py\u001b[0m in \u001b[0;36mtrace_to_subjaxpr_dynamic\u001b[0;34m(fun, main, in_avals)\u001b[0m\n\u001b[1;32m   1262\u001b[0m     \u001b[0min_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_arg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_avals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1263\u001b[0;31m     \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0min_tracers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1264\u001b[0m     \u001b[0mout_tracers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_raise\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mans\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/linear_util.py\u001b[0m in \u001b[0;36mcall_wrapped\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m       \u001b[0mans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m     \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-69-4b2549d67db6>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(_, GRF_seed)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m    135\u001b[0m   \u001b[0;31m#Random phase realisation in Fourier space\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 136\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    137\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m     48\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m   \u001b[0;32mif\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     50\u001b[0m     \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36m__bool__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    541\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__nonzero__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_nonzero\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 542\u001b[0;31m   \u001b[0;32mdef\u001b[0m \u001b[0m__bool__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_bool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    543\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__int__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_int\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/core.py\u001b[0m in \u001b[0;36merror\u001b[0;34m(self, arg)\u001b[0m\n\u001b[1;32m    986\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 987\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mConcretizationTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfname_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    988\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: jax._src.errors.ConcretizationTypeError: Abstract tracer value encountered where concrete value is expected: Traced<ShapedArray(int64[])>with<DynamicJaxprTrace(level=1/0)>\nThe problem arose with the `bool` function. \nWhile tracing the function <lambda> at <ipython-input-69-4b2549d67db6>:2 for scan, this concrete value was not available in Python because it depends on the value of the argument 'GRF_seed'.\n\nSee https://jax.readthedocs.io/en/latest/errors.html#jax.errors.ConcretizationTypeError\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mConcretizationTypeError\u001b[0m                   Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-70-b1b57523e422>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGRFs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seeds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m<ipython-input-69-4b2549d67db6>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(_, GRF_seed)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#g = jax.jit(lambda _,GRF_seed: (1,np.ones((npix,npix))*GRF_seed))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mget_jaxified_GRF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGRF_params\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mGRF_seed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpix_scl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_jaxified_GRF\u001b[0;34m(params, seed, npix, pix_scl)\u001b[0m\n\u001b[1;32m    134\u001b[0m   \u001b[0msqrt_power_array\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk_grid\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mbeta\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mmask_center\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    135\u001b[0m   \u001b[0;31m#Random phase realisation in Fourier space\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 136\u001b[0;31m   \u001b[0mphase_realisation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    137\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    138\u001b[0m   \u001b[0;31m#Create fourier image with random phases\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/content/drive/My Drive/Jax_Strong_Lensing//Modules/jaxtronomy/GaussianRandomField/PowerBox_jaxified.py\u001b[0m in \u001b[0;36mget_phase_realisation\u001b[0;34m(npix, seed)\u001b[0m\n\u001b[1;32m     47\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_phase_realisation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnpix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     48\u001b[0m   \u001b[0;34m\"A random array which has Gaussian magnitudes and Hermitian symmetry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m   \u001b[0;32mif\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     50\u001b[0m     \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mConcretizationTypeError\u001b[0m: Abstract tracer value encountered where concrete value is expected: Traced<ShapedArray(int64[])>with<DynamicJaxprTrace(level=1/0)>\nThe problem arose with the `bool` function. \nWhile tracing the function <lambda> at <ipython-input-69-4b2549d67db6>:2 for scan, this concrete value was not available in Python because it depends on the value of the argument 'GRF_seed'.\n\nSee https://jax.readthedocs.io/en/latest/errors.html#jax.errors.ConcretizationTypeError"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "hEhaBSiYRNzV",
-        "outputId": "d65c6609-843d-408d-eae0-80ad9e8406cc"
-      },
-      "source": [
-        "GRFs"
-      ],
-      "execution_count": 55,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "DeviceArray([[[2., 2., 2., ..., 2., 2., 2.],\n",
-              "              [2., 2., 2., ..., 2., 2., 2.],\n",
-              "              [2., 2., 2., ..., 2., 2., 2.],\n",
-              "              ...,\n",
-              "              [2., 2., 2., ..., 2., 2., 2.],\n",
-              "              [2., 2., 2., ..., 2., 2., 2.],\n",
-              "              [2., 2., 2., ..., 2., 2., 2.]],\n",
-              "\n",
-              "             [[3., 3., 3., ..., 3., 3., 3.],\n",
-              "              [3., 3., 3., ..., 3., 3., 3.],\n",
-              "              [3., 3., 3., ..., 3., 3., 3.],\n",
-              "              ...,\n",
-              "              [3., 3., 3., ..., 3., 3., 3.],\n",
-              "              [3., 3., 3., ..., 3., 3., 3.],\n",
-              "              [3., 3., 3., ..., 3., 3., 3.]],\n",
-              "\n",
-              "             [[4., 4., 4., ..., 4., 4., 4.],\n",
-              "              [4., 4., 4., ..., 4., 4., 4.],\n",
-              "              [4., 4., 4., ..., 4., 4., 4.],\n",
-              "              ...,\n",
-              "              [4., 4., 4., ..., 4., 4., 4.],\n",
-              "              [4., 4., 4., ..., 4., 4., 4.],\n",
-              "              [4., 4., 4., ..., 4., 4., 4.]],\n",
-              "\n",
-              "             ...,\n",
-              "\n",
-              "             [[7., 7., 7., ..., 7., 7., 7.],\n",
-              "              [7., 7., 7., ..., 7., 7., 7.],\n",
-              "              [7., 7., 7., ..., 7., 7., 7.],\n",
-              "              ...,\n",
-              "              [7., 7., 7., ..., 7., 7., 7.],\n",
-              "              [7., 7., 7., ..., 7., 7., 7.],\n",
-              "              [7., 7., 7., ..., 7., 7., 7.]],\n",
-              "\n",
-              "             [[8., 8., 8., ..., 8., 8., 8.],\n",
-              "              [8., 8., 8., ..., 8., 8., 8.],\n",
-              "              [8., 8., 8., ..., 8., 8., 8.],\n",
-              "              ...,\n",
-              "              [8., 8., 8., ..., 8., 8., 8.],\n",
-              "              [8., 8., 8., ..., 8., 8., 8.],\n",
-              "              [8., 8., 8., ..., 8., 8., 8.]],\n",
-              "\n",
-              "             [[9., 9., 9., ..., 9., 9., 9.],\n",
-              "              [9., 9., 9., ..., 9., 9., 9.],\n",
-              "              [9., 9., 9., ..., 9., 9., 9.],\n",
-              "              ...,\n",
-              "              [9., 9., 9., ..., 9., 9., 9.],\n",
-              "              [9., 9., 9., ..., 9., 9., 9.],\n",
-              "              [9., 9., 9., ..., 9., 9., 9.]]], dtype=float64)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 55
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "fKrMW5BKOrur"
-      },
-      "source": [
-        "GRF_seeds=np.arange(2,10)"
-      ],
-      "execution_count": 22,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "31bkJ2eTPLnD",
-        "outputId": "32f499df-70cb-4baf-821d-cb4035fcbffd"
-      },
-      "source": [
-        "GRF_seeds"
-      ],
-      "execution_count": 26,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "array([2, 3, 4, 5, 6, 7, 8, 9])"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 26
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "bYNbPnvoP4Uv"
-      },
-      "source": [
-        "def map(f, xs):\n",
-        "    return np.stack([f(x) for x in xs])"
-      ],
-      "execution_count": 34,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "ABovifh1P5wV",
-        "outputId": "ce70da44-9a57-4973-e084-3dc4acc11577"
-      },
-      "source": [
-        "map(g,GRF_seeds)"
-      ],
-      "execution_count": 36,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "array([[[-0.00570171, -0.00129161,  0.0058245 , ..., -0.00757102,\n",
-              "         -0.00243726, -0.01649447],\n",
-              "        [ 0.00493164, -0.00220677, -0.00262641, ..., -0.01041471,\n",
-              "         -0.0095766 , -0.01066423],\n",
-              "        [-0.00321968, -0.01664846, -0.00271096, ..., -0.0238819 ,\n",
-              "         -0.00081087, -0.00673764],\n",
-              "        ...,\n",
-              "        [-0.00682896,  0.00358378,  0.00185109, ..., -0.00034693,\n",
-              "         -0.0172854 , -0.01211973],\n",
-              "        [ 0.00313957,  0.00894859,  0.00696749, ...,  0.00331316,\n",
-              "         -0.01668601, -0.00939343],\n",
-              "        [-0.01528318,  0.00801151,  0.00499301, ...,  0.00171082,\n",
-              "          0.00492917, -0.01536378]],\n",
-              "\n",
-              "       [[ 0.00245054, -0.00181478,  0.00855211, ..., -0.00014682,\n",
-              "          0.00316356,  0.0037077 ],\n",
-              "        [-0.01105917,  0.00272392,  0.00126246, ..., -0.00935565,\n",
-              "          0.00261621, -0.00807424],\n",
-              "        [ 0.00189058,  0.01246546, -0.00043618, ..., -0.00888243,\n",
-              "         -0.00943269, -0.01652462],\n",
-              "        ...,\n",
-              "        [ 0.00740169,  0.00177444,  0.00654389, ...,  0.00113258,\n",
-              "          0.0074417 ,  0.02392809],\n",
-              "        [-0.00511541,  0.00459735,  0.01046327, ...,  0.01150066,\n",
-              "         -0.00035693,  0.01335217],\n",
-              "        [-0.00960982, -0.00622419,  0.00907952, ...,  0.00919878,\n",
-              "          0.01221109,  0.00588644]],\n",
-              "\n",
-              "       [[-0.0139905 , -0.01638946, -0.0172895 , ..., -0.02114541,\n",
-              "         -0.02840538, -0.01410159],\n",
-              "        [-0.01689089, -0.00574568, -0.00956084, ..., -0.00669177,\n",
-              "         -0.01476772, -0.01590232],\n",
-              "        [-0.01420469, -0.00935511, -0.01111654, ..., -0.00626801,\n",
-              "         -0.0099091 , -0.01716254],\n",
-              "        ...,\n",
-              "        [-0.0137148 , -0.00494926, -0.0020264 , ..., -0.01500677,\n",
-              "         -0.01389189, -0.01912288],\n",
-              "        [-0.0272826 , -0.00955068, -0.00430711, ..., -0.02163854,\n",
-              "         -0.01288849, -0.01248661],\n",
-              "        [-0.01883318, -0.02027143, -0.00810125, ..., -0.01875949,\n",
-              "         -0.02265133, -0.01283164]],\n",
-              "\n",
-              "       ...,\n",
-              "\n",
-              "       [[-0.01230228, -0.01800172, -0.02579664, ...,  0.0073786 ,\n",
-              "          0.00191748, -0.00412699],\n",
-              "        [-0.02118216, -0.01941043, -0.02257236, ..., -0.0082184 ,\n",
-              "         -0.00647608, -0.00765698],\n",
-              "        [-0.02644685, -0.01421645, -0.02074588, ..., -0.01580186,\n",
-              "         -0.00524229, -0.00874206],\n",
-              "        ...,\n",
-              "        [-0.0135957 , -0.01621485, -0.01872369, ...,  0.00644837,\n",
-              "         -0.01356566, -0.01610557],\n",
-              "        [-0.01129862, -0.00167056, -0.01800664, ..., -0.00673788,\n",
-              "         -0.00021035, -0.0225168 ],\n",
-              "        [-0.01089003, -0.00209198, -0.01326153, ..., -0.0069217 ,\n",
-              "          0.00692525, -0.0028887 ]],\n",
-              "\n",
-              "       [[ 0.01655477,  0.0056518 ,  0.00598932, ...,  0.01250736,\n",
-              "          0.02933828,  0.03217609],\n",
-              "        [ 0.00895991,  0.01713715,  0.0227057 , ...,  0.02304084,\n",
-              "          0.01878312,  0.01828753],\n",
-              "        [ 0.02908461,  0.03373585,  0.01912583, ...,  0.01770112,\n",
-              "          0.024731  ,  0.02216083],\n",
-              "        ...,\n",
-              "        [ 0.0212948 ,  0.01322786,  0.01144615, ...,  0.001536  ,\n",
-              "          0.00905991,  0.01523457],\n",
-              "        [ 0.01169935,  0.00222409,  0.02501316, ...,  0.00011715,\n",
-              "          0.00060522,  0.00872047],\n",
-              "        [ 0.00594872,  0.00560278,  0.01655162, ...,  0.01192272,\n",
-              "          0.01623821,  0.00911491]],\n",
-              "\n",
-              "       [[ 0.01839963,  0.01470064,  0.0126376 , ..., -0.00092679,\n",
-              "          0.00714594,  0.0190327 ],\n",
-              "        [ 0.00196516, -0.00613721,  0.00104802, ...,  0.00682581,\n",
-              "         -0.00405272,  0.0004448 ],\n",
-              "        [-0.01414344, -0.00324376,  0.00613208, ...,  0.0101815 ,\n",
-              "         -0.00572056, -0.00116558],\n",
-              "        ...,\n",
-              "        [-0.01421333, -0.00510635,  0.004092  , ..., -0.00255698,\n",
-              "         -0.00059953, -0.00947415],\n",
-              "        [ 0.00629259,  0.0113965 ,  0.00846697, ...,  0.01365204,\n",
-              "          0.00871522,  0.00343058],\n",
-              "        [ 0.01040981,  0.02313104,  0.01368947, ...,  0.00845253,\n",
-              "          0.00874118,  0.02016828]]])"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 36
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 596
-        },
-        "id": "5lMpvhDdOck0",
-        "outputId": "a9c2d00f-7bff-4052-cc89-e51a3bf69412"
-      },
-      "source": [
-        "jax.lax.scan(test, 0, tuple([1,2,3]))[1]"
-      ],
-      "execution_count": 33,
-      "outputs": [
-        {
-          "output_type": "error",
-          "ename": "ValueError",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1227\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1228\u001b[0;31m     \u001b[0mlengths\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxs_flat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1229\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m   1227\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1228\u001b[0;31m     \u001b[0mlengths\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mxs_flat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1229\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute 'shape'",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-33-28a14e864087>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1232\u001b[0m       msg.format(', '.join(str(x) for x in xs_flat\n\u001b[0;32m-> 1233\u001b[0;31m                            if not hasattr(x, 'shape')))) from err\n\u001b[0m\u001b[1;32m   1234\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: ValueError: scan got value with no leading axis to scan over: 1, 2, 3.\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-33-28a14e864087>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/lax/control_flow.py\u001b[0m in \u001b[0;36mscan\u001b[0;34m(f, init, xs, length, reverse, unroll)\u001b[0m\n\u001b[1;32m   1231\u001b[0m     raise ValueError(\n\u001b[1;32m   1232\u001b[0m       msg.format(', '.join(str(x) for x in xs_flat\n\u001b[0;32m-> 1233\u001b[0;31m                            if not hasattr(x, 'shape')))) from err\n\u001b[0m\u001b[1;32m   1234\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1235\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mlength\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mValueError\u001b[0m: scan got value with no leading axis to scan over: 1, 2, 3."
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Jd0-NY0vMyno"
-      },
-      "source": [
-        "q=lambda GRF_seed: get_jaxified_GRF_pure([GRF_LogAmp,GRF_beta],GRF_seed)"
-      ],
-      "execution_count": 17,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "TYp4CcLbKWmb"
-      },
-      "source": [
-        "q_mapped=jax.vmap(get_jaxified_GRF_pure,in_axes=(0,None,),out_axes=(None,))"
-      ],
-      "execution_count": 18,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 596
-        },
-        "id": "VBhzVnQYNPlO",
-        "outputId": "05deaa08-2b95-454f-b7b0-e8c13cdba6d7"
-      },
-      "source": [
-        "q_mapped([2,3])"
-      ],
-      "execution_count": 20,
-      "outputs": [
-        {
-          "output_type": "error",
-          "ename": "ValueError",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_mapped_axis_size\u001b[0;34m(tree, vals, dims, name, kws)\u001b[0m\n\u001b[1;32m   1305\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1306\u001b[0;31m     \u001b[0msize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmapped_axis_sizes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1307\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0msize\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 1, got 0)",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m                      Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-20-8bd21f1e5033>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mq_mapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/traceback_util.py\u001b[0m in \u001b[0;36mreraise_with_filtered_traceback\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    163\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36mbatched_fun\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1282\u001b[0m     \u001b[0min_axes_flat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatten_axes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"vmap in_axes\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0min_axes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1283\u001b[0;31m     \u001b[0maxis_size\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_mapped_axis_size\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0min_tree\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0min_axes_flat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"vmap\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1284\u001b[0m     out_flat = batching.batch(\n",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_mapped_axis_size\u001b[0;34m(tree, vals, dims, name, kws)\u001b[0m\n\u001b[1;32m   1309\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mmapped_axis_sizes\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1310\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"{name} must have at least one non-None value in in_axes\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1311\u001b[0m     \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{name} got inconsistent sizes for array axes to be mapped:\\n\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"{}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mUnfilteredStackTrace\u001b[0m: ValueError: vmap must have at least one non-None value in in_axes\n\nThe stack trace below excludes JAX-internal frames.\nThe preceding is the original exception that occurred, unmodified.\n\n--------------------",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-20-8bd21f1e5033>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mq_mapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/jax/_src/api.py\u001b[0m in \u001b[0;36m_mapped_axis_size\u001b[0;34m(tree, vals, dims, name, kws)\u001b[0m\n\u001b[1;32m   1308\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1309\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mmapped_axis_sizes\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1310\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"{name} must have at least one non-None value in in_axes\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1311\u001b[0m     \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{name} got inconsistent sizes for array axes to be mapped:\\n\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"{}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1312\u001b[0m     \u001b[0;31m# we switch the error message based on whether args is a tuple of arrays,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mValueError\u001b[0m: vmap must have at least one non-None value in in_axes"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "Bx5wCk5VK8He",
-        "outputId": "d3239e00-3980-4f7b-cf5e-3635fd9db800"
-      },
-      "source": [
-        "unperturbed_image.shape"
-      ],
-      "execution_count": 16,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "(100, 100)"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 16
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "BXbopWnRJ2g1"
-      },
-      "source": [
-        "\n",
-        "def GRF_Loss_phase_averaging(GRF_params,GRF_seed_array,unperturbed_image,\n",
-        "             get_jaxified_GRF_pure,simulate_perturbed_image_pure,\\\n",
-        "             compute_radial_spectrum_pure,Spectra_Loss_pure):\n",
-        "\n",
-        "  (npix,_)=unperturbed_image.shape\n",
-        "  phase_number=len(GRF_seed_array)\n",
-        "  GRFs=jnp.ones((phase_number,npix,npix))\n",
-        "\n",
-        "  \n",
-        "\n",
-        "  GRF=get_jaxified_GRF_pure(GRF_params,GRF_seed)\n",
-        "\n",
-        "  simulated_image=simulate_perturbed_image_pure(GRF)\n",
-        "\n",
-        "  resid=simulated_image-unperturbed_image\n",
-        "  resid_spectrum=compute_radial_spectrum_pure(resid)\n",
-        "\n",
-        "  return Spectra_Loss_pure(resid_spectrum)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "qoEHwfDQJvRZ"
-      },
-      "source": [
-        "## MAE loss function"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "lkzMiBL4WFpB"
-      },
-      "source": [
-        "Spectra_Loss_pure=purify_function(Spectra_Loss_MAE,resid_true_spectrum)"
-      ],
-      "execution_count": 15,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "9ndZ7s2XJuAd"
-      },
-      "source": [
-        ""
-      ],
-      "execution_count": null,
-      "outputs": []
-    }
-  ]
-}
\ No newline at end of file

From cf148a837d596ff327b0500cb306e20137d17432 Mon Sep 17 00:00:00 2001
From: Aymeric Galan <aymeric.galan@gmail.com>
Date: Wed, 1 Sep 2021 15:58:05 +0200
Subject: [PATCH 3/4] Add option to overwite pixelated coordinate grids

---
 jaxtronomy/Analysis/plot.py          | 19 ++++++++++---------
 jaxtronomy/Coordinates/pixel_grid.py |  4 ++--
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/jaxtronomy/Analysis/plot.py b/jaxtronomy/Analysis/plot.py
index 9f45f47..bb78d00 100644
--- a/jaxtronomy/Analysis/plot.py
+++ b/jaxtronomy/Analysis/plot.py
@@ -4,13 +4,13 @@
 import jax.numpy as jnp
 import matplotlib.pyplot as plt
 from scipy import ndimage
-from matplotlib.colors import LogNorm
+from matplotlib.colors import Normalize, LogNorm
 
 from jaxtronomy.Util.plot_util import nice_colorbar, nice_colorbar_residuals
 from jaxtronomy.Util import image_util
 
 # Some general default for plotting
-plt.rc('image', interpolation='none', origin='lower')  # imshow
+plt.rc('image', interpolation='none', origin='lower')  # for imshow
 
 
 class Plotter(object):
@@ -32,19 +32,20 @@ class Plotter(object):
     cmap_flux = copy.copy(cmap_base)
     cmap_flux.set_bad(color='black')
     cmap_flux_alt = copy.copy(cmap_base)
-    cmap_flux_alt.set_bad(color='#222222')  # emphasize e.g. non-positive pixels in log scale
+    cmap_flux_alt.set_bad(color='#222222')  # to emphasize non-positive pixels in log scale
     cmap_resid = plt.get_cmap('RdBu_r')
     cmap_default = plt.get_cmap('viridis')
     cmap_deriv1 = plt.get_cmap('cividis')
     cmap_deriv2 = plt.get_cmap('inferno')
 
     def __init__(self, base_fontsize=0.28, flux_log_scale=True, 
-                 flux_vmin=None, flux_vmax=None):
+                 flux_vmin=None, flux_vmax=None, res_vmax=6):
         self._base_fs = base_fontsize
         if flux_log_scale is True:
             self.norm_flux = LogNorm(flux_vmin, flux_vmax)
         else:
             self.norm_flux = None
+        self.norm_res = Normalize(-res_vmax, res_vmax)
 
     def set_data(self, data):
         self._data = data
@@ -167,12 +168,12 @@ def model_summary(self, lens_image, kwargs_result,
             nice_colorbar(im, position='top', pad=0.4, size=0.2, 
                           colorbar_kwargs={'orientation': 'horizontal'})
             ax = axes[i_row, 2]
-            norm_res = lens_image.normalized_residuals(data, model, mask=likelihood_mask)
+            residuals = lens_image.normalized_residuals(data, model, mask=likelihood_mask)
             red_chi2 = lens_image.reduced_chi2(data, model, mask=likelihood_mask)
-            im = ax.imshow(norm_res * likelihood_mask, cmap=self.cmap_resid, vmin=-4, vmax=4, extent=extent)
+            im = ax.imshow(residuals * likelihood_mask, cmap=self.cmap_resid, extent=extent, norm=self.norm_res)
             ax.set_title(r"(f${}_{\rm model}$ - f${}_{\rm data})/\sigma$", fontsize=self._base_fs)
-            nice_colorbar_residuals(im, norm_res, position='top', pad=0.4, size=0.2, 
-                                    vmin=-4, vmax=4,
+            nice_colorbar_residuals(im, residuals, position='top', pad=0.4, size=0.2, 
+                                    vmin=self.norm_res.vmin, vmax=self.norm_res.vmax,
                                     colorbar_kwargs={'orientation': 'horizontal'})
             text = r"$\chi^2={:.2f}$".format(red_chi2)
             ax.text(0.05, 0.05, text, color='black', # fontsize=, 
@@ -202,7 +203,7 @@ def model_summary(self, lens_image, kwargs_result,
                 diff = source_model - true_source
                 vmax_diff = true_source.max() / 10.
             im = ax.imshow(diff, extent=src_extent, 
-                           cmap=self.cmap_resid, vmin=-vmax_diff, vmax=vmax_diff)
+                           cmap=self.cmap_resid, norm=Normalize(-vmax_diff, vmax_diff))
             ax.set_title(r"s${}_{\rm model}$ - s${}_{\rm truth}$", fontsize=self._base_fs)
             nice_colorbar_residuals(im, diff, position='top', pad=0.4, size=0.2, 
                                     vmin=-vmax_diff, vmax=vmax_diff,
diff --git a/jaxtronomy/Coordinates/pixel_grid.py b/jaxtronomy/Coordinates/pixel_grid.py
index de2a84b..9bf659b 100644
--- a/jaxtronomy/Coordinates/pixel_grid.py
+++ b/jaxtronomy/Coordinates/pixel_grid.py
@@ -120,7 +120,7 @@ def model_pixel_extent(self, name):
 
     def create_model_grid(self, grid_center=None, grid_shape=None, 
                           pixel_scale_factor=None, conserve_extent=False,
-                          name='none'):
+                          name='none', overwrite=False):
         """
         :param grid_center: 2-tuple (center_x, center_y) with grid center in physical units
         If None, defaults to the original grid center. 
@@ -134,7 +134,7 @@ def create_model_grid(self, grid_center=None, grid_shape=None,
         Otherwise, the extent will be computed based on the final pixel width.
         :param name: unique string for identifying the created grid.
         """
-        if name in self._model_grids:
+        if not overwrite and name in self._model_grids:
             raise ValueError(f"Grid name '{name}' is already used for another grid")
         
         unchanged_count = 0

From 04e1d19f15f2cf28f2a02c9e9f3dea23e9bb002d Mon Sep 17 00:00:00 2001
From: Aymeric Galan <aymeric.galan@gmail.com>
Date: Wed, 1 Sep 2021 16:10:47 +0200
Subject: [PATCH 4/4] Update notebooks for GRF and localised dark substructures

---
 notebooks/fit_pixelated_GRF_potential.ipynb   | 428 ++++++------------
 .../fit_pixelated_compact_potential.ipynb     | 394 +++++++---------
 ...mpact_potential_and_pixelated_source.ipynb |   2 +-
 3 files changed, 298 insertions(+), 526 deletions(-)

diff --git a/notebooks/fit_pixelated_GRF_potential.ipynb b/notebooks/fit_pixelated_GRF_potential.ipynb
index 54b2a65..7fcfb16 100644
--- a/notebooks/fit_pixelated_GRF_potential.ipynb
+++ b/notebooks/fit_pixelated_GRF_potential.ipynb
@@ -4,11 +4,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Find a localised dark matter halo\n",
+    "# Gaussian random fields (GRF) perturbations along LOS\n",
     "### Fit pixelated lens potential perturbations on top of a smooth SIE model, assuming an elliptical Sérsic source.\n",
     "The potential perturbation here is Gaussian Random Field of perturbations to the underlying SIE potential.\n",
     "\n",
-    "__last update__: 30/07/21"
+    "__last update__: 1/09/21"
    ]
   },
   {
@@ -20,10 +20,8 @@
     "# Basic imports\n",
     "from time import time\n",
     "import numpy as np\n",
-    "from scipy.optimize import minimize, Bounds, LinearConstraint\n",
     "import matplotlib.pyplot as plt\n",
     "from copy import deepcopy\n",
-    "from scipy import ndimage\n",
     "import powerbox as pbox\n",
     "%matplotlib inline\n",
     "plt.rc('image', interpolation='none')\n",
@@ -44,12 +42,13 @@
     "from jaxtronomy.Parameters.parameters import Parameters\n",
     "from jaxtronomy.Inference.loss import Loss\n",
     "from jaxtronomy.Inference.optimization import Optimizer\n",
-    "from jaxtronomy.Inference.sampling import Sampler\n",
-    "from jaxtronomy.Util import image_util\n",
-    "from jaxtronomy.Util.jax_util import WaveletTransform\n",
+    "from jaxtronomy.Analysis.plot import Plotter\n",
     "\n",
     "# Universal font size\n",
-    "FS = 18"
+    "FS = 18\n",
+    "\n",
+    "# Plotting engine for modeling results\n",
+    "plotter = Plotter(base_fontsize=FS, flux_vmin=5e-2, flux_vmax=5e-1, res_vmax=4)"
    ]
   },
   {
@@ -83,10 +82,10 @@
     "half_size = npix * pix_scl / 2\n",
     "ra_at_xy_0 = dec_at_xy_0 = -half_size + pix_scl / 2\n",
     "transform_pix2angle = pix_scl * np.eye(2)\n",
-    "kwargs_pixel = {'nx': npix, 'ny': npix,\n",
+    "kwargs_grid = {'nx': npix, 'ny': npix,\n",
     "                'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0,\n",
     "                'transform_pix2angle': transform_pix2angle}\n",
-    "pixel_grid = PixelGrid(**kwargs_pixel)\n",
+    "pixel_grid = PixelGrid(**kwargs_grid)\n",
     "\n",
     "# Native image plane coordinates\n",
     "x_grid, y_grid = pixel_grid.pixel_coordinates\n",
@@ -94,12 +93,6 @@
     "y_coords = y_grid[:, 0]\n",
     "extent = [x_coords[0], x_coords[-1], y_coords[0], y_coords[-1]]\n",
     "\n",
-    "# Lower resolution interpolation grid\n",
-    "npix_lowres = npix // 4\n",
-    "x_coords_lowres = np.linspace(extent[0], extent[1], npix_lowres)\n",
-    "y_coords_lowres = np.linspace(extent[2], extent[3], npix_lowres)\n",
-    "x_grid_lowres, y_grid_lowres = np.meshgrid(x_coords_lowres, y_coords_lowres)\n",
-    "\n",
     "print(f\"image size : ({npix}, {npix}) pixels\")\n",
     "print(f\"pixel size : {pix_scl} arcsec\")\n",
     "print(f\"x range    : {extent[0], extent[1]} arcsec\")\n",
@@ -110,7 +103,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Source light model"
+    "### PSF\n",
+    "Ignore the PSF for now."
    ]
   },
   {
@@ -118,6 +112,44 @@
    "execution_count": 3,
    "metadata": {},
    "outputs": [],
+   "source": [
+    "kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': 0.3}\n",
+    "psf = PSF(**kwargs_psf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Noise"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Noise\n",
+    "exp_time = None\n",
+    "sigma_bkd = 0.01\n",
+    "kwargs_noise = {'background_rms': sigma_bkd,  'exposure_time': exp_time}\n",
+    "noise = Noise(npix, npix, **kwargs_noise)\n",
+    "noise_hybrid = deepcopy(noise)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Source light model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "source_light_model_list = ['SERSIC_ELLIPSE']\n",
     "source_light_model = LightModel(source_light_model_list)\n",
@@ -134,7 +166,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -174,7 +206,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -182,11 +214,13 @@
     "true_lens_mass_model_list = ['SIE', 'PIXELATED']\n",
     "true_lens_mass_model = LensModel(true_lens_mass_model_list)\n",
     "kwargs_true_lens_mass = [{'theta_E': 1.6, 'e1': 0.15, 'e2': -0.04, 'center_x': 0.0, 'center_y': 0.0},\n",
-    "                         {'x_coords': x_coords, 'y_coords': x_coords, 'psi_grid': psi_pert_highres}]\n",
+    "                         {'pixels': psi_pert_highres}]\n",
     "\n",
     "# Hybrid lens mass model\n",
     "hybrid_lens_mass_model_list = ['SIE', 'PIXELATED']\n",
-    "hybrid_lens_mass_model = LensModel(hybrid_lens_mass_model_list)\n",
+    "kwargs_pixelated_lens = {'pixel_scale_factor': 4, 'conserve_extent': True}\n",
+    "hybrid_lens_mass_model = LensModel(hybrid_lens_mass_model_list,\n",
+    "                                   kwargs_pixelated=kwargs_pixelated_lens)\n",
     "\n",
     "# Lens light\n",
     "lens_light_model_list = []\n",
@@ -196,12 +230,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
+     ]
+    }
+   ],
+   "source": [
+    "kwargs_numerics = {'supersampling_factor': 1}\n",
+    "pixel_grid_copy = deepcopy(pixel_grid)\n",
+    "\n",
+    "# True image model\n",
+    "true_lens_image = LensImage(pixel_grid, psf, noise_class=noise_hybrid,\n",
+    "                                lens_model_class=true_lens_mass_model,\n",
+    "                                source_model_class=source_light_model,\n",
+    "                                lens_light_model_class=lens_light_model,\n",
+    "                                kwargs_numerics=kwargs_numerics)\n",
+    "\n",
+    "# Hybrid image model for fitting\n",
+    "hybrid_lens_image = LensImage(pixel_grid_copy, psf, noise_class=noise_hybrid,\n",
+    "                                lens_model_class=hybrid_lens_mass_model,\n",
+    "                                source_model_class=source_light_model,\n",
+    "                                lens_light_model_class=lens_light_model,\n",
+    "                                kwargs_numerics=kwargs_numerics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "scrolled": false
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1080x288 with 6 Axes>"
       ]
@@ -213,18 +281,19 @@
     }
    ],
    "source": [
+    "# Extract coordinate grids for pixelated potential\n",
+    "x_grid_lowres, y_grid_lowres = hybrid_lens_image.Grid.model_pixel_coordinates('lens')\n",
+    "\n",
     "# Extract the true perturbation potential on original and low-res grids\n",
-    "psi_grid_true = true_lens_mass_model.potential(x_grid, y_grid, kwargs_true_lens_mass, k=1)\n",
-    "psi_grid_true_lowres = true_lens_mass_model.potential(x_grid_lowres, y_grid_lowres, kwargs_true_lens_mass, k=1)\n",
+    "psi_grid_true = true_lens_image.LensModel.potential(x_grid, y_grid, kwargs_true_lens_mass, k=1)\n",
+    "psi_grid_true_lowres = true_lens_image.LensModel.potential(x_grid_lowres, y_grid_lowres, kwargs_true_lens_mass, k=1)\n",
     "\n",
     "# Set the hybrid lens mass model parameters\n",
     "kwargs_hybrid_lens_mass = [kwargs_true_lens_mass[0],\n",
-    "                           {'x_coords': x_coords_lowres, \n",
-    "                            'y_coords': y_coords_lowres, \n",
-    "                            'psi_grid': psi_grid_true_lowres}]  # Transpose so that image_model works properly\n",
+    "                           {'pixels': psi_grid_true_lowres}]  # Transpose so that image_model works properly\n",
     "\n",
     "# Test interpolating the low-res hybrid model to the original grid\n",
-    "psi_grid_interp = hybrid_lens_mass_model.potential(x_grid, y_grid, kwargs_hybrid_lens_mass, k=1)\n",
+    "psi_grid_interp = hybrid_lens_image.LensModel.potential(x_grid, y_grid, kwargs_hybrid_lens_mass, k=1)\n",
     "\n",
     "# Plot\n",
     "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n",
@@ -239,45 +308,6 @@
     "fig.tight_layout()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### PSF\n",
-    "Ignore the PSF for now."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': 0.3}\n",
-    "psf = PSF(**kwargs_psf)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Noise"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Noise\n",
-    "exp_time = None\n",
-    "sigma_bkd = 0.01\n",
-    "kwargs_noise = {'background_rms': sigma_bkd,  'exposure_time': exp_time}\n",
-    "noise = Noise(npix, npix, **kwargs_noise)\n",
-    "noise_hybrid = deepcopy(noise)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -287,21 +317,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 11,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Warning: previous noise map will be replaced with new estimate from a model\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x288 with 4 Axes>"
       ]
@@ -314,29 +337,21 @@
    ],
    "source": [
     "# Generate a lensed image based on source and lens models\n",
-    "kwargs_numerics = {'supersampling_factor': 1, 'supersampling_convolution': False}\n",
-    "lens_image = LensImage(pixel_grid, psf,\n",
-    "                       noise_class=noise,\n",
-    "                         lens_model_class=true_lens_mass_model,\n",
-    "                         source_model_class=source_light_model,\n",
-    "                         lens_light_model_class=lens_light_model,\n",
-    "                         kwargs_numerics=kwargs_numerics)\n",
-    "\n",
-    "image = lens_image.model(kwargs_lens=kwargs_true_lens_mass,\n",
+    "image = true_lens_image.model(kwargs_lens=kwargs_true_lens_mass,\n",
     "                          kwargs_source=kwargs_source_light,\n",
     "                          kwargs_lens_light=kwargs_lens_light)\n",
     "\n",
     "\n",
     "# Observed noisy data\n",
-    "data = lens_image.simulation(kwargs_lens=kwargs_true_lens_mass,\n",
+    "data = true_lens_image.simulation(kwargs_lens=kwargs_true_lens_mass,\n",
     "                             kwargs_source=kwargs_source_light,\n",
     "                             kwargs_lens_light=kwargs_lens_light)\n",
     "\n",
     "# Plot\n",
     "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))\n",
-    "img1 = ax1.imshow(image, origin='lower', extent=extent)\n",
+    "img1 = ax1.imshow(image, origin='lower', extent=extent, cmap=plotter.cmap_flux, norm=plotter.norm_flux)\n",
     "ax1.set_title(\"Clean lensing image\", fontsize=FS)\n",
-    "img2 = ax2.imshow(data, origin='lower', extent=extent)\n",
+    "img2 = ax2.imshow(data, origin='lower', extent=extent, cmap=plotter.cmap_flux, norm=plotter.norm_flux)\n",
     "ax2.set_title(\"Noisy observation data\", fontsize=FS)\n",
     "for img, ax in zip((img1, img2), (ax1, ax2)):\n",
     "    fig.colorbar(img, ax=ax)\n",
@@ -345,12 +360,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x576 with 8 Axes>"
       ]
@@ -362,13 +377,6 @@
     }
    ],
    "source": [
-    "# Hybrid image model for fitting\n",
-    "hybrid_lens_image = LensImage(pixel_grid, psf, noise_class=noise_hybrid,\n",
-    "                                lens_model_class=hybrid_lens_mass_model,\n",
-    "                                source_model_class=source_light_model,\n",
-    "                                lens_light_model_class=lens_light_model,\n",
-    "                                kwargs_numerics=kwargs_numerics)\n",
-    "\n",
     "# Test the hybrid model with the true low-res perturbation grid\n",
     "hybrid_image = hybrid_lens_image.model(kwargs_lens=kwargs_hybrid_lens_mass,\n",
     "                                        kwargs_source=kwargs_source_light,\n",
@@ -418,19 +426,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "truths: 625 dpsi_0\n",
+      "truths: 625 d_0\n",
       "uniform\n"
      ]
     }
    ],
    "source": [
+    "npix_lowres = npix // kwargs_pixelated_lens['pixel_scale_factor']\n",
     "masked_lower = -10.*np.ones(npix_lowres**2)*mask_lowres.flatten()\n",
     "masked_upper = +10.*np.ones(npix_lowres**2)*mask_lowres.flatten()\n",
     "\n",
@@ -440,20 +449,18 @@
     "    'lens_light_model_list': lens_light_model_list,\n",
     "}\n",
     "kwargs_init = {\n",
-    "    'kwargs_lens': [{}, {'psi_grid': 1e-8 * np.zeros((npix_lowres, npix_lowres))}],\n",
+    "    'kwargs_lens': [{}, {'pixels': 1e-8}],\n",
     "    'kwargs_source': [{}],\n",
     "}\n",
     "kwargs_prior = {\n",
-    "    #'kwargs_lens': [{}, {}],\n",
-    "    #'kwargs_lens': [{}, {'psi_grid': ['uniform', -np.inf, +np.inf]}],\n",
-    "    'kwargs_lens': [{}, {'psi_grid': ['uniform', masked_lower, masked_upper]}],\n",
+    "    'kwargs_lens': [{}, {'pixels': ['uniform', masked_lower, masked_upper]}],\n",
     "    'kwargs_source': [{}],\n",
     "}\n",
     "kwargs_fixed = {\n",
-    "    'kwargs_lens': [kwargs_hybrid_lens_mass[0], {'x_coords': x_coords_lowres, 'y_coords': y_coords_lowres}],\n",
+    "    'kwargs_lens': [kwargs_hybrid_lens_mass[0], {}],\n",
     "    'kwargs_source': kwargs_source_light,\n",
     "}\n",
-    "parameters = Parameters(kwargs_model, kwargs_init, kwargs_prior, kwargs_fixed)\n",
+    "parameters = Parameters(hybrid_lens_image, kwargs_init, kwargs_prior, kwargs_fixed)\n",
     "\n",
     "kwargs_true = {\n",
     "    'kwargs_lens': kwargs_hybrid_lens_mass, \n",
@@ -476,12 +483,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -510,7 +517,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -542,7 +549,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 16,
    "metadata": {
     "scrolled": false
    },
@@ -564,107 +571,11 @@
     "hybrid_image_init = hybrid_lens_image.model(**parameters.args2kwargs(p_init))\n",
     "\n",
     "plt.title(\"Initial residuals\", fontsize=FS)\n",
-    "plt.imshow((data - hybrid_image_init) / np.sqrt(lens_image.Noise.C_D), origin='lower', cmap='RdBu_r', vmin=-4, vmax=4)\n",
+    "plt.imshow((data - hybrid_image_init) / np.sqrt(true_lens_image.Noise.C_D), origin='lower', cmap='RdBu_r', vmin=-4, vmax=4)\n",
     "plt.colorbar()\n",
     "plt.show()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_pixelated_potential_result(optimizer, kwargs_f, shift_potential='min', with_mask=True):\n",
-    "    if optimizer is not None:\n",
-    "        fig, ax = plt.subplots(1, 1)\n",
-    "        ax.plot(range(len(optimizer.loss_history)), optimizer.loss_history)\n",
-    "        ax.set_ylabel(\"Loss\", fontsize=FS)\n",
-    "        ax.set_xlabel(\"Iteration\", fontsize=FS)\n",
-    "        plt.show()\n",
-    "        \n",
-    "    # create the resulting model image\n",
-    "    rec_image = hybrid_lens_image.model(**kwargs_f)\n",
-    "    noise_var = lens_image.Noise.C_D\n",
-    "    alpha_x, alpha_y = hybrid_lens_image.LensModel.alpha(x_grid_lowres, y_grid_lowres, kwargs_final['kwargs_lens'], k=1)\n",
-    "    kappa = hybrid_lens_image.LensModel.kappa(x_grid_lowres, y_grid_lowres, kwargs_final['kwargs_lens'], k=1)\n",
-    "\n",
-    "    # Reshape the final psi grid\n",
-    "    psi_grid_rec = kwargs_f['kwargs_lens'][1]['psi_grid']\n",
-    "    if shift_potential == 'min':\n",
-    "        min_in_mask = (psi_grid_rec * mask_lowres).min()\n",
-    "        psi_grid_rec = psi_grid_rec - min_in_mask\n",
-    "        print(\"delta_psi shift by min:\", min_in_mask)\n",
-    "    elif shift_potential == 'mean':\n",
-    "        mean_in_mask = (psi_grid_rec * mask_lowres).mean()\n",
-    "        true_mean_in_mask = (psi_grid_true_lowres * mask_lowres).mean()\n",
-    "        psi_grid_rec = psi_grid_rec - mean_in_mask + true_mean_in_mask\n",
-    "        print(\"delta_psi shift & normalization by mean:\", mean_in_mask, true_mean_in_mask)\n",
-    "        \n",
-    "    fig, axes = plt.subplots(3, 3, figsize=(15, 14))\n",
-    "    ax = axes[0, 0]\n",
-    "    img = ax.imshow(data, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"Data\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[0, 1]\n",
-    "    img = ax.imshow(rec_image, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"Image reconstruction\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[0, 2]\n",
-    "    img = ax.imshow((data - rec_image) / jnp.sqrt(noise_var), origin='lower', cmap='RdBu_r', vmin=-4, vmax=4, extent=extent)\n",
-    "    ax.set_title(\"Normalised residuals\", fontsize=FS)\n",
-    "    ax.set_xlabel(f\"Chi-sq : {np.mean((data - rec_image)**2 / noise_var):.2f}\")\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "\n",
-    "    ax = axes[1, 0]\n",
-    "    psi_grid_true_show = psi_grid_true_lowres\n",
-    "    if with_mask:\n",
-    "        psi_grid_true_show *= mask_lowres\n",
-    "    img = ax.imshow(psi_grid_true_show, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"True $\\delta\\psi$\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[1, 1]\n",
-    "    psi_grid_rec_show = psi_grid_rec\n",
-    "    if with_mask:\n",
-    "        psi_grid_rec_show *= mask_lowres\n",
-    "    img = ax.imshow(psi_grid_rec_show, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"Reconstructed $\\delta\\psi$\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[1, 2]\n",
-    "    abs_res_show = (psi_grid_true_lowres - psi_grid_rec)\n",
-    "    if with_mask:\n",
-    "        abs_res_show *= mask_lowres\n",
-    "    vmax = 0.5 * np.max(np.abs(psi_grid_true_lowres))\n",
-    "    img = ax.imshow(abs_res_show, origin='lower', cmap='RdBu_r', vmin=-vmax, vmax=vmax, extent=extent)\n",
-    "    ax.set_title(\"Absolute residuals\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "\n",
-    "    ax = axes[2, 0]\n",
-    "    alpha_x_rec_show = alpha_x\n",
-    "    if with_mask:\n",
-    "        alpha_x_rec_show *= mask_lowres\n",
-    "    ax.set_title(r\"$\\delta\\alpha_x$\", fontsize=FS)\n",
-    "    im = ax.imshow(alpha_x_rec_show, origin='lower', alpha=1, extent=extent)\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "    ax = axes[2, 1]\n",
-    "    alpha_y_rec_show = alpha_y\n",
-    "    if with_mask:\n",
-    "        alpha_y_rec_show *= mask_lowres\n",
-    "    ax.set_title(r\"$\\delta\\alpha_y$\", fontsize=FS)\n",
-    "    im = ax.imshow(alpha_y_rec_show, origin='lower', alpha=1, extent=extent)\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "    ax = axes[2, 2]\n",
-    "    #kappa_rec_show = kappa\n",
-    "    kappa_rec_show = ndimage.gaussian_filter(kappa, 1)\n",
-    "    if with_mask:\n",
-    "        kappa_rec_show *= mask_lowres\n",
-    "    ax.set_title(r\"$\\delta\\kappa$ (smoothed)\", fontsize=FS)\n",
-    "    im = ax.imshow(kappa_rec_show, origin='lower', cmap='inferno', alpha=1, extent=extent, vmin=0)\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "    \n",
-    "    plt.show()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -681,7 +592,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -728,60 +639,6 @@
     "print(\"mean level within mask:\", np.mean(dpsi_noise_map2[mask_lowres == 1.]))"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Visualise wavelet transforms of true $\\delta\\psi$"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of starlet scales: 4\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1440x216 with 12 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# we consider the maximum number of starlet scales\n",
-    "n_scales = int(np.log2(npix_lowres))\n",
-    "print(\"Number of starlet scales:\", n_scales)\n",
-    "starlet = WaveletTransform(n_scales, wavelet_type='starlet')\n",
-    "coeffs_true = starlet.decompose(psi_grid_true_lowres)\n",
-    "\n",
-    "fig, axes = plt.subplots(1, coeffs_true.shape[0]+1, figsize=(20, 3))\n",
-    "for s in range(coeffs_true.shape[0]):\n",
-    "    ax = axes[s]\n",
-    "    ax.set_title(f\"scale {s}\", fontsize=FS)\n",
-    "    im = ax.imshow(coeffs_true[s, ...], origin='lower')\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "ax = axes[-1]\n",
-    "ax.set_title(\"recon. error\", fontsize=FS)\n",
-    "im = ax.imshow(np.sum(coeffs_true, axis=0) - psi_grid_true_lowres, origin='lower')\n",
-    "fig.colorbar(im, ax=ax)\n",
-    "plt.show()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -798,8 +655,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Loss at initial values: 2.480076066317041\n",
-      "Loss at true values: 1.8205996782924558\n"
+      "Loss at initial values: 2.480076066317042\n",
+      "Loss at true values: 1.5550462546123733\n"
      ]
     }
    ],
@@ -813,8 +670,9 @@
     "            likelihood_type='l2_norm',\n",
     "            regularization_terms=['l1_starlet_potential', \n",
     "                                  'l1_battle_potential'], \n",
-    "            regularization_strengths=[(5, 3), 10],\n",
-    "            potential_noise_map=dpsi_noise_map)\n",
+    "            regularization_strengths=[(3, 1), 10],\n",
+    "            potential_noise_map=dpsi_noise_map,\n",
+    "            prior_terms=None)\n",
     "\n",
     "print(\"Loss at initial values:\", loss(p_init))\n",
     "print(\"Loss at true values:\", loss(p_true))"
@@ -838,8 +696,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Runtime: 33.36912202835083\n",
-      "Loss at best-fit: 1.240443853558617\n"
+      "Runtime: 33.365700244903564\n",
+      "Loss at best-fit: 1.1518982331567897\n"
      ]
     }
    ],
@@ -854,35 +712,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "scrolled": false
-   },
+   "execution_count": 21,
+   "metadata": {},
    "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "delta_psi shift & normalization by mean: 0.004376447239836079 0.01354391219480172\n"
+      "delta_psi shift by mean values: 0.0066524890156234445 0.013543912194801727\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 1080x1008 with 18 Axes>"
+       "<Figure size 1080x1440 with 24 Axes>"
       ]
      },
      "metadata": {
@@ -892,9 +736,13 @@
     }
    ],
    "source": [
-    "kwargs_final = deepcopy(parameters.ML_values(as_kwargs=True))\n",
-    "plot_pixelated_potential_result(optimizer, kwargs_final,\n",
-    "                                shift_potential='mean', with_mask=True)"
+    "plotter.set_true_potential_perturbations(psi_grid_true_lowres)\n",
+    "plotter.set_data(data)\n",
+    "\n",
+    "kwargs_final = deepcopy(parameters.best_fit_values(as_kwargs=True))\n",
+    "plotter.model_summary(hybrid_lens_image, kwargs_final,\n",
+    "                      show_lens_mass=True, potential_mask=mask_lowres,\n",
+    "                      shift_potential_model='mean')"
    ]
   },
   {
diff --git a/notebooks/fit_pixelated_compact_potential.ipynb b/notebooks/fit_pixelated_compact_potential.ipynb
index ef5e862..2f5ef8a 100644
--- a/notebooks/fit_pixelated_compact_potential.ipynb
+++ b/notebooks/fit_pixelated_compact_potential.ipynb
@@ -8,7 +8,7 @@
     "### Fit pixelated lens potential perturbations on top of a smooth SIE model, assuming an elliptical Sérsic source.\n",
     "The potential perturbation here is a single SIE localised substructure on the Einstein ring.\n",
     "\n",
-    "__last update__: 30/07/21"
+    "__last update__: 01/09/21"
    ]
   },
   {
@@ -23,7 +23,6 @@
     "import matplotlib.pyplot as plt\n",
     "from copy import deepcopy\n",
     "import corner\n",
-    "from scipy import ndimage\n",
     "%matplotlib inline\n",
     "plt.rc('image', interpolation='none')\n",
     "\n",
@@ -43,11 +42,13 @@
     "from jaxtronomy.Parameters.parameters import Parameters\n",
     "from jaxtronomy.Inference.loss import Loss\n",
     "from jaxtronomy.Inference.optimization import Optimizer\n",
-    "from jaxtronomy.Inference.sampling import Sampler\n",
-    "from jaxtronomy.Util import image_util\n",
+    "from jaxtronomy.Analysis.plot import Plotter\n",
     "\n",
     "# Universal font size\n",
-    "FS = 18"
+    "FS = 18\n",
+    "\n",
+    "# Plotting engine for modeling results\n",
+    "plotter = Plotter(base_fontsize=FS, flux_vmin=5e-2, flux_vmax=5e-1, res_vmax=4)"
    ]
   },
   {
@@ -81,10 +82,10 @@
     "half_size = npix * pix_scl / 2\n",
     "ra_at_xy_0 = dec_at_xy_0 = -half_size + pix_scl / 2\n",
     "transform_pix2angle = pix_scl * np.eye(2)\n",
-    "kwargs_pixel = {'nx': npix, 'ny': npix,\n",
+    "kwargs_grid = {'nx': npix, 'ny': npix,\n",
     "                'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0,\n",
     "                'transform_pix2angle': transform_pix2angle}\n",
-    "pixel_grid = PixelGrid(**kwargs_pixel)\n",
+    "pixel_grid = PixelGrid(**kwargs_grid)\n",
     "\n",
     "# Native image plane coordinates\n",
     "x_grid, y_grid = pixel_grid.pixel_coordinates\n",
@@ -92,18 +93,51 @@
     "y_coords = y_grid[:, 0]\n",
     "extent = [x_coords[0], x_coords[-1], y_coords[0], y_coords[-1]]\n",
     "\n",
-    "# Lower resolution interpolation grid\n",
-    "npix_lowres = npix // 4\n",
-    "x_coords_lowres = np.linspace(extent[0], extent[1], npix_lowres)\n",
-    "y_coords_lowres = np.linspace(extent[2], extent[3], npix_lowres)\n",
-    "x_grid_lowres, y_grid_lowres = np.meshgrid(x_coords_lowres, y_coords_lowres)\n",
-    "\n",
     "print(f\"image size : ({npix}, {npix}) pixels\")\n",
     "print(f\"pixel size : {pix_scl} arcsec\")\n",
     "print(f\"x range    : {extent[0], extent[1]} arcsec\")\n",
     "print(f\"y range    : {extent[2], extent[3]} arcsec\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### PSF\n",
+    "Ignore the PSF for now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': 0.3}\n",
+    "psf = PSF(**kwargs_psf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Noise"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Noise\n",
+    "exp_time = None\n",
+    "sigma_bkd = 0.05\n",
+    "kwargs_noise = {'background_rms': sigma_bkd, 'exposure_time': exp_time}\n",
+    "noise = Noise(npix, npix, **kwargs_noise)\n",
+    "noise_hybrid = deepcopy(noise)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -113,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -132,7 +166,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -144,7 +178,9 @@
     "\n",
     "# Hybrid lens mass model\n",
     "hybrid_lens_mass_model_list = ['SIE', 'PIXELATED']\n",
-    "hybrid_lens_mass_model = LensModel(hybrid_lens_mass_model_list)\n",
+    "kwargs_pixelated_lens = {'pixel_scale_factor': 4, 'conserve_extent': True}\n",
+    "hybrid_lens_mass_model = LensModel(hybrid_lens_mass_model_list,\n",
+    "                                   kwargs_pixelated=kwargs_pixelated_lens)\n",
     "\n",
     "# Lens light\n",
     "lens_light_model_list = []\n",
@@ -152,14 +188,45 @@
     "kwargs_lens_light = [{}]"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Image model"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "kwargs_numerics = {'supersampling_factor': 1}\n",
+    "pixel_grid_copy = deepcopy(pixel_grid)\n",
+    "\n",
+    "# True image model\n",
+    "true_lens_image = LensImage(pixel_grid, psf, noise_class=noise_hybrid,\n",
+    "                                lens_model_class=true_lens_mass_model,\n",
+    "                                source_model_class=source_light_model,\n",
+    "                                lens_light_model_class=lens_light_model,\n",
+    "                                kwargs_numerics=kwargs_numerics)\n",
+    "\n",
+    "# Hybrid image model for fitting\n",
+    "hybrid_lens_image = LensImage(pixel_grid_copy, psf, noise_class=noise_hybrid,\n",
+    "                                lens_model_class=hybrid_lens_mass_model,\n",
+    "                                source_model_class=source_light_model,\n",
+    "                                lens_light_model_class=lens_light_model,\n",
+    "                                kwargs_numerics=kwargs_numerics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABCUAAAEtCAYAAAA/Y9pYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACR+0lEQVR4nO29e7gsVXnn/327997nHC4KeBQRiOBIokYTTU4wmWQiiiLJGImTi5gbJBjGTJhcZjIRY35CMCaok9sMJnqCDOoYL2OiniQkiBdCLmLAS7zg7YgXDl4QDnc4e+/uen9/1FrVq7rerlrdXd1Ve9f38zz76e5V77pUdfVbtVe973eJqoIQQgghhBBCCCFk2fSaHgAhhBBCCCGEEEK6CSclCCGEEEIIIYQQ0giclCCEEEIIIYQQQkgjcFKCEEIIIYQQQgghjcBJCUIIIYQQQgghhDQCJyUIIYQQQgghhBDSCJyUIJ1BRE4SERWRi5fc77mu39OW2S8hZDpE5GL3Wz2p6bFMQkSuFZEvNT2OpqE/J4QskkVeD0TkNNf2uXW3TchWZdtPSgQ//N9oeixkMs75/2jT45gVd55dLCJHNT0WQmahDl/p/mH7tRqHtaUQkSc7P3BS02NpEvpzQrY2vB7MD68HhEzHtp+UIFuGiwD8aNODmIPTkO7DUca2NwHYBeC6JY6HkCY4F8CvNTyGJnkyUj9wUrPDaBz6c0LIueD1YNL14DqkfuRNSxwPIa2GkxItRkRWRWRn0+NYFMvaPxHZJSIri+5nEqo6VNVDqpo0NQZCtjpN/45JOfTnhJBl0bQfmBdVTZwfGTY9lnkQkSNn2VZXH2R7wUmJABH5QRG5RkTuFpEHReQjInLemM1FLqTt5KDsOFeWiMgxQfnjXfmLI/r2uWvfLiJ/KCIHABwC8L1u+w4R+S0R+ZSIHBKRu0Tkr0XkKWPt9ETk10Tk4yJyr4jcIyKfFZHXi8hqxRiyHF0ReYFr45CIfMWVFS4Abt//zNlsiMhXRWSviDwicv/OFhF1Zuc4G/VlZXnDVr6fiFzpyh4uIleIyDcA3A/ghLG6lfsnIo8TkT91x/xeEXlARD4sIi8cs7sS6Ww4AHwx2IeL3XYzB1lEdovIa0TkFnfsbnGfHzZm5+s/Q0R+Q0S+ICLrIvI5ETnHOC7/UUT+QURud+fxV0Tkr0TkW8dtCSljzCc8R0RucL+Zr4nIq8PfjKQ6B08D8Ojwdxye9yJyioi8ydXfEJEvuXYOH+t34u94Rj/1HSLyThG5w9neJCK/KSL9iGPwKBH5AxH5mIjcGdR/cVjf/d7/j/v4gWD/rwxsovy4sz1aRP7c/Y7vl1RL4rurxhvUpz/P29CfEzIHwutBbdcDmaApISKHi8jvB37h6yLyRhF59JhdVl9Eft75tXUR+bKI/GbVfoy19XwR+afAL35IRH7csFP3XZzu7O8D8Ndu25ckvUY9RUSuFpG7AXw8qFv5/5Wzu9a19RgReYeIHARwzzT7Q7YuW3aWsW5E5EcAvBPA1wH8AYB7AZwN4HIReYyqvtSZvh/AxQCeAeD1rux0AAnSSZ6nA/hLV/6MoE4sbwbwoBuDAviapJMJfw/g3yMN9boMwEMB/CKAfxaRH1TVG139lwK4BKmjeC2AIYCTATwXwA4AmxFjeC6AxwB4DdLj8VykN2mPBvDz3khEvgXABwGsIT0WXwDwWAC/BODpIrJHVe+u2L+PAvhZt1//CGBvxPhiuMaN/eUADgdwH4Ajptk/pCG8PwjgbwB80bXzEwD+XEQerqq/7+xeB+AhAJ4H4NcB3O7KP44JiMhDAfwL0uN1BYCPAHgK0mP3DBE5VVXvHav2e0jD/V4HYN3ZXiki+1X1n127TwOwD8AnAfw+gLsAPArAM11fn5t4xAiZzA8D+C9IfcoVAM4C8BsA7kR6XgJpmO7vA9iN9Hfg+TQASPoP9fuRnpOvA3ArgO8E8CsAvl9Enqaq4/5p7t+xiOwB8A9IfZ+3/REAr3T9/3TFvn8HgP+E9PrwBQCrAM4EcKnr/z87u78CcByA890x+bQr/4IbR7Qfd7ZXA/geZ3s90lDg9wK4o2K849Cfp5wG+nNC6oDXgzmvBxaB3/9+AO9A6ldPQeobznA++MBYtRcBOBapz74LwM8AeKWIHFDVv6jYF4jI7yL9v+HvAfx/SP+XeR6A/yciF6jqa8aq7AHwYwD+HMAbxrZ9C9Lv9P8h/T/oCNdH7P9XniOQfkf/7Mb2CJBuoKrb+g/pjYgC+I0Smz6AL8Nd8IPyNaQ/iiGAU1zZKtIZ2jcHdlcA+DCAmwD8aVD+l67NfsQ4L3bjvBbAyti2X3fbnj1W/hAAXwFwbVD2EQA3zXisTnL9DAF8V1AuSB2KAvjeoPzdAG4DcMJYO3sADABcHLN/brsCuLJkTBcb23ybJwVlV7qy/1vD/h1utNFz+3A3gNWysQTbznXbTgvKXuHK/suY7S+78pcb9T8KYC0oPx7pzexbgrI/dLaPaPq3x7+t9QfDVwa/mfvHfmeC9B+lr421cS2AL01o/98AfAbAkWPlz3N9nBuU1fk7/mfnj75jzPbtzvb0oNzyKbsAiDGON7kxHBeUFX7rwbZp/Pj5zvZ3xmx/zZWbx3jO40R/XjKWsu8Y9Of822Z/4PVgkk+q63rgj2+4n7/oyl41ZvsfXfmbjPpfBfDQoPwwAN8E8MGI7/i7XBu/Z2x7F9IIhSODMnV/zzTsv+S2vXCsPPr/q+CcUQC/2/RvgH/L/2P6Rsp3I53hu0JVv+oLVXUDwKuQ3ric5co2AfwT0ogIz9MBvM/9nQ4AIiJIQ9f+QafLGftjVR2Mlf0MUuf9YUlDRHeLyG6kP+prAPyAiOxytncDOF5EfmCKPse5RlU/4j+oqiI9DkB6wfBPhp6D9CnOobFxfQnAfgBnRO7fIvifJdsq98+V3+/fi8hOScNwjwHwHqT/SDxujvE9D+mFY/xJ4utc+fMKNdIJr41gfLcifVJ2SmDjn2T+mBW2SMiMvEtVv+Q/uN/MBwA8UkSOmFjLISJPQvqE6S8A7BjzF/+E9CbX8hdz/Y4lTTv49wD2qerHx2xfEdpOQlUfdPYQkTUROcaN+2qk14Y9ZfUDpvHjP4r0Zu0Pxtr4M0wfykp/DvpzQmqE1wPMfT2weB7SSIXfDwtV9W8BfAzAWSIy/n/b/9Eggk1VH0AaWXcKqvlppBMAbwi/A7c/+wAcCeD7xur8m6q+d0J7BzFKWfFE/381Rtl3TbYpvMileH2ITxnbfNljgrL3Iw2lejzSJxsnubJdAC4QkeMBPBzAwxCkbkiqN7EWNq6qXx/rzwrHfLxr+5sl+7AbwC0AfgvpDOc/ishXkc46/i2Ad4Q3QBV82ii7yb364/BtSJ3Jee7P4majbFnhpmX9xOwf3MX1YgA/CeBEo87Rsw4O6Tl34/gNvaoORORzSGewx7GO5x1IwxM9lyF18H+KNITvn5CG5b1FVcvOH0LKmHTuAamfu6+i/uPd6++4P4tjjbJ5f8dlvv3TSG8AH2Nsy3D/DF4I4OeQhszLmEmsH5jGjz8G6VPH3ASEqq6LyM1T9AnQnwOgPyekRng9mP96YHEygK+q6p3Gtk8hTeHbjTSizTPpu3iYUT7O45GO/zMlNuPfQ9l38AXjIey0/18BwDdV9a6Sfsg2hZMSs+EnGp6BdFJiE2n+7BpSp3Y6UscR2gJpjtnTxtoad2gPGP0JgE8A+G8lY/omAKjqB0Xk3wF4NtIIjqcD+CkAvy0iP6CqB0vamAY/7v+LYl6Z50GjzNq/MrRk28Tz180Wz8tfIH16uBfp8k13IH16+cNIQ7GXHWk0KeImO4dU9Q4R+R4A/wHAs5DmUP8RgN8RkR9W1Q8ufphkG1IW7TXuw8ps/gDpP1UWhRuxmn7H8/KHAP4rgLchfZp2G1Kf/11I85Bj/UC0H28A+nP6c0Ji4fVg/utBXcyzeocg9ck/VNLO+GRC2XdQ1/fThu+ZNAAnJVL8TOO3G9ueMGYDpLoNdyOdfFgH8CEXGnq/iHzUlR+D1Fl9Mqj33zHbLOrnkUZevF8jliFT1fuQ6ln8JQCIyH9BKuhzHoBXR/T3eKNs/DjsR+rM1kpCuerAT6IcY2wrndEuoXL/ROQopDewb1LVF4WGIvJMo37ZzbbFzQC+TURWwqdrbhb+W2HPfkfhZqqvdX8Qke9Aqnny20hzEwlZFJN+B593r8Ma/UWMn/qie7V8++OQ3kBW/dZ+FsB1qnp2WCgijzVsy/zANH78ZqTReA8JoyVEZAdSv2c9SZsE/Tn9OSFNwOvBdNwM4EwROcqIFHgC0tS92wu1ZufzSEU6v6KqVqRJHUz7/xXpMNSUSPkIUqGxnxeRR/pCp4T7P5A6lnf7cneT8A9Iox6ejnw0xPuRTkr8IFLhMg3qfVhV3xv+RY7vjQAeiQlP2ETk2OD9bsPE59lZN4IWzxKRLNzU6WP4JYbeBaRPcABcBeA/icj3GmMSEXl4ZH9AGu5XGJ+miuVfR6pgns3Ai8hjkOZdz0Ll/mE0a5yb9ReR4wDklpBz+HDF2GP8LqT/oIy39Yuu/J2R7eSY8P1/BulTztixETIr9wE4OvytOj6KdIL2Re63m0NEViRYTjmSGD91G9JVEX5ERJ44ZvsS97HqtzZE0Q8cjryivKfMD0T7caTXmz7SieyQX0KqfzAN9Of054Q0Aa8HKdP4kR7S9JCw/R9CuprPvpgHk1PwJvf6e2Ishzp2TZqVqf6/It2mS5ESp4vITqP8dlV9rYhcgNQZ3SAie5EuWfN8AN+LVJn282P13o90ySH/Piz/H0b5PPwJ0tDNV4vIM1y79yAVjzkd6frwXnjz0yJyPYAPIVXl9UsSbQB4a2R//wbg/SLyGgBfQ5rT+kykT5nCcNFfQipKdJ2IvBHphaaH9InXWUhvwi+O7PN6AM8UkRcjdWCqqn68lwH4XQB/JyLvQrok2ouQXtS+J7L9qfZPVe8VkfcA+BkReRDADUhzff8z0tn28Xy9693rK0XkzUi/k0+q6idh8yqky9G9xl1IP4r0onMegM9iJNA0LX8uIicgFW/7MtIc9ucjFSx644xtEhLL9UifSF8mIv+C9Abu/ap6m4j8LFLf9XERuQJpWOhhSPNy/xPSm8Irp+gr1k/9KtJJ5H90tl93Y3w2gL9Q1fdV9PMOAP9ZRN6GdEnOYwH8AuylOW9AmsL3UhE5Gqlg2xdV9UOYzo//H6R++2UicjLSpTqfgtRnfAHTXbvpz+nPCWkCXg8mXw8srgRwDoAXi8hJSNPMHot0+dVvINWMqw1VvUFELkbq1z8mIv8Po/8bvhtpatvaxAbi+hjO8P8V6SragiVAFvmH0bI5k/4+E9g+DakK+j1Ib0I+CuC8Ce0+ydV/APllvQ5HOgGgCJa5iRjnxZiwBJnbvoJ0/eYbkDq2+5GGXr0ZwBmB3YVIHdltSFNLbkG6ZvB3RYzhJDeGiwG8AOm67L6NSxAsmRbU2Y00JeRz7pjdhTRv+k8APGGK/TsF6Y3XPf67Gdv3VyG90BxCOvP6I1abcEtH1bF/bt8uR+qkD7n9+kVMWOYJ6az8zUjzCxVu2bsS+4cjFTA74OocQJpms3vMzqzvtl2LYMktpBfzfa6tdaQ56v8A4Mea/i3yr91/KF8C7mLD3vr9HYZ0vfRvIL0BzZ23SP8RfC3SFR02kN7IfRip2viJgV1tv2NX5zuRPoU66Gw/7X6v/ch9ejXSfwoPIfW7FyKdSFAES7o5+3OQCqz568CVwbYoP+5sj3HH8g5ndy1SZffcb77k+5zlONGfj+zpz/nX2T/welC2T3NfD2AsCerKD3f7f7OrcxvSiIZHT/h+zjX2b+LxmnAM/yPS1UP88bgFwN8BeNGYXe56NrbtSwiWtTa2R/1/hcjrG/+255+4k4AQuJnZLwL4HVW9uNnREEJIEfqpOHicCCHbHfo5QrYP1JQghBBCCCGEEEJII3BSghBCCCGEEEIIIY3ASQlCCCGEEEIIIYQ0AjUlCCGEEEIIIYQQ0giMlCCEEEIIIYQQQkgjTLPWeW3sPqavJ524Wmm3iSSqvc3IYI+B9uPaQ5xdbHsDjZv7ibUb1myXqNRqp9F2UWbR7cWyXYKDJPawSNwORzcX2d6D+79+u6o+PLLZAs9++uF6x8FhtP2HP75+taqeOWm7Wwv9OQBuU9UnGtsfCuD/AvgWpL7xf6rq/5l64C3H+1/F6HvU7HVU5r1vGE03spNCWWKU5ezUqisT2wt/9yM7GGVVfVhjKWsPBTtU2hX7GLcP7SZtHx+09UvL2ZvtGWVT+tBcG/S/JtH+t7SR0cGYtrl8//mDunHb3Rjc/cDMI5zW9wLV/pcAO47apbseeWTTwyCEzIF1zZbAB9/92W+26t53K9HIpMRJJ67iX68+sdLutuH9Ue19fRg3OfD1QdzF4JvDh0TZfWPzoVF2t28eEWV31+CwKLuDG3F2923uiLK7f3Mtyu7BzeqJJABY34w7rTYjv7fBIHJyZVjvJEzdN+OxxP7TL724SbuVlVi7OCe42o+z+9hzfu/LUYYTuP3gEB+6+oRo+9XjvrC7wuRKAJcBeOOE7b8M4CZV/REReTiAz4rIm1V1I3oQWwDvfzd19D3695sYla1ret5sBP9F+gngzeCivOkmPw8Fk7Sb7v0GimWbOvIPG0ZZVjfX3kpu2+Sy/uSypNxu4LaHkyu+Tjhh7MtCP+K3D5KRXeLLgrp+uxp1w/b89rA9/y0Mc31Iob3ET2gEZb6ONeGSm/wx6poTM6Zdwcz0ofZETwnL8MMVPtcagemnXZk1YRHa++35smLdUVlx8qJn1k1fP/trV5j7Ecu0vheI8r+dZ9cjj8Rpl/945htCehJ3nSaENIN1Tfes9QbZ+3f/hz9r273vlqGRSQlCCKlGMdT6btRU9Tq3pvnkDoEjRUQAHAHgIIBBiT0hhGxD6vW9hBBCYumu/+WkBCGklSiApPwZat1cBmAfgK8COBLA81W335VB3QUvCdLjfITEZrC7Q/foOzwAPkJiM4wccO+HwfNkHyFhRTZURUCURU/YZRWREslku0EueqJXKPNRE2GUhR0V4SIbcpEXxQiIoREVMTTtZKKdFRWRWNETGDFtVEQY9WCVwWgv24SiXa7IzkmJou5UvlEEghXaEPSb2RtjCSMmXFnYmu/DGroEDUZHSrjtSVDmoyZ6ZfszBQ343s4w0H7ud+2/syQyHXgr0YO/hhTPxx7Pr2gYRVMfVpRSdF3jPE6ya3V9Eo1d9r+clCCEtJYkUlfGsVtEbgw+71XVvVPUfzaAjwF4BoB/B+AaEflHVb1nmkEQQshWZ0rfSwghpCa66n85KUEIaSXpE/2pZotvV9U9c3T58wAu1VTZcb+IfBHA4wD86xxttg4FMMAwpymRuOO8GepH+NfgK/BP8MNIiQ23iFMYieCfGrRdP2Izp/cwuSx8QuIjIAZG9IQV2RDmn/rtli7E0IhYyNu518ioiCSxIiCqIiX8m3JR0NIICEt8U42wA4uKSIg6RDJz0Q5lEQWGZoQd7RB+8O2G24sRFVmVoCwbSy4qIi3r9cq1J9R98NET8x6nGXwvmYJepG7UXH0YP7SmIhYYFTEbjJBYHNaxrTPaYR667H85KUEIaS1LDmH7CoDTAfyjiBwL4NsA3LzMARBCSBvoavgwIYQ0TVf9LyclCCGtRAEMa3TMIvIWAKchTfM4AOAiAKsAoKqvBfByAFeKyCeQPsx8sareXtsACCFkC1C37wWilmT+HwB+2n1cAfB4AA9X1YMi8iUA9wIYAhjMGRFHCCGtZRH+d6vASQlCSGupc7ZYVV9Qsf2rAM6orcMWM1TNiVpuuuMcLvbq0zY2QlFLFEUty5b6zNu1W9TSKpt2qc9hRarGwFia0xS6TIrpFmXLesamaoR2lliljm0L60anZUSLWxq5ELE/91ncgpFaUWZni18WBSdzKSAlKR9SPPQ5octsOVEtlg2DZn0dS/yyF7lMdAwLeFJ3JUqWZFbVVwN4NQCIyI8A+HVVPRiYPH07TBL3oLk0imWmNnQljaIsNL8qJSLWjmxNyr7Xyu/cp2mGv99MZLje84WREoQQ0iIU6GxeHSGENMUifG/EkswhLwDwlloHQAghW4Au3/s2MikxRIK7kwcr7e4Yxi1rdXB4WKTdEVF23xwcGWV3+2Zce3dsHh5ld+dG3H7cvb4ryu6+zbUouwc3VqPs1jfjTpfNjTi74TBOVEYHkXaR5wuSWLs4s2hiV2mLtevHOa1BP25Heqtxdisrw2qjmuCzivpRKDYxzIUHbmRClyM7H+XgoyPS7UVRy6HbnhOrRDHawbe3SFHL9aRY1y/TGQpJlolaWhEQsUt9hhEVZUt9htETI1FLQ+jSEJysiopIsigLjJgjKiKrY7ZXLMtREmVRJWrZ2IMia1jGUpvm8C1Ry5KIilxQhLfLlU0WyZQgKiKrq8VlY2dlBt877+pHAAAROQzAmQAuCIoVwHskDQ953SzttoWeJNkT10I5WRixx5ffA2kDXT0LGSlBCGklCu1sXh0hhDTFjL533tWPPD8C4J/HUjd+QFVvFZFHIF2q+TOqel0NfRFCSKvo8r0vJyUIIe1E87nUhBBClkCzvvdsjKVuqOqt7vU2EXkngFMBcFKCELL96PC9LyclCCGtRNHdELZFogA2NcFmEHvvj/NmTpiymH7g0yI2UEyjSHJpHumlxUrVyNvVK2rpU0kGhl2YluHLwn2zRC0HmUhmMS1jUCFqaaVqJEaqRmKkeSSlaRkzCFia6RYo2FlilWqURadlmNsr6rQRM1UjYhuCXRN7+6ismKqBnua3BXU1OK+slI55aMr3ishDATwNwM8EZYcD6Knqve79GQAuaWB4hBCycLp878tJCUJIS5Hc6g2EEEKWQf2+N2JJZgB4HoD3qOr9QdVjAbzT6WusAPgLVf37WgdHCCGtobv3vpyUIIS0EgWQdDSEbZH4WfjNoMwLXA5zURFOwDKIbMjEL40IiDAqYpgJYhYjIDZy4pdF4cxYUUvLLhOwNJb1tMoGRhSDJWqZW9ZTjbKSpT5z0RPWUp8lURFJThATBTs1oycioyJKBDFh1I2OgJhFwLLkdy5LiKJQYynP3D1htoZnWGY0ZAhimhEVRpkZUZH1q8WiUCtxLHpiXuH2RfjeqiWZnc2VSJcODctuBvCd9Y6GEELaSZfvfTkpQQhpJYr8P8SEEEIWD30vIYQ0Q5f9LyclCCGtJWl7rjkhhGxD6HsJIaQZuup/OSlBCGklCnQ2r26RqCo2VHPqzhs+xSEyVWMYiDxulIhVhukgPm3DSssY5gQ240QtNzMRyrDMEOc0hC59usWgIqVDs5QOQ+iyQtRSszIp1E2MdItQrNIuc69hH/41J3SZbyNtqIZUDatuSIn4pZmCMWUaR9T2acmyMozxVQhYenKpH5lYZWhQ0k50SseoUJz4Zfhdmikdc0DfSwghzdBl/8tJCUJIK1FIpjlACCFkOdD3EkJIM3TZ/zYyKTFQxcHhsNLuYHJYVHt3DI+Isvvm4CFRdrdvHhnX7+bhcXbrcXZ3b+yKsrt3fUeU3QMbq1F26+txdoONfrURgGQzzg6bkTOBwzg7GUTaJZH9xj6Vi7WL7TbWF/XjOtZ+XIPDlbj2ktXI77cGuhrCtmhSoctAWDGLiigu1xleHLOoiGBJ0MQQq7SiJ/x3aQtYBuKXhjBlqahlLgKiWJYJWCZFOyt6YmiUhVEHI7tiBETsUp+JYRc++c62G3Vzy3W6dcOioyISo6wqUmJ8W/BerIgKq07kMqCW3uTEMcxKlQ5n2fZcVIR/KRe1zCIpqoQzPYaAZU7oMqtbEj1Rg9+k7yWEkGboqv/t5lQMIaT1+BC22D9CCCHzM63vpf8lhJB6WMS9r4icKSKfFZH9InKhsX2HiLzNbf+QiJwUbHuJK/+siDw7KP+SiHxCRD4mIjfWsOtM3yCEtBXJPbUmhBCyDOh7CSGkGer1vyLSB/AaAM8CcADADSKyT1VvCszOA3Cnqj5WRM4G8EoAzxeRJwA4G8C3A3gUgPeKyLeqqk93eLqq3l7XWDkpQQhpJYpRagCpDwWwqfn0A5/uEM66W0KXo1SN0aVjw0jz2DRFLdOyJEwRScrEL4upJJaoZVXZoLQsFKs0yoxUDR9WOczZ+bSMovhlkhO/RKHMp2qoIXQZpmWMhC4NUctcmZGWkRhlkaKWUprmgSJBe2Y6RlndgNJUjlnSOGIf5pcKXBZTNcwo22DwYolfZnWL6SCw0gvDIn/qWCkdNQpd0vcSQsjyWYD/PRXAflW9GQBE5K0AzgIQTkqcBeBi9/4dAC6T9OJ1FoC3quo6gC+KyH7X3gfrHKCHkxKEkNbCsGBCCFk+9L2EENIMNfvf4wHcEnw+AOCpk2xUdSAidwN4mCu/fqzu8e69AniPiCiA16nq3nkHykkJQkgrUWUI8SJQl4c4z/KfQy2PihgaERWWWGVi9uujIopilVWilmUClklwkS8TtRxWLPU5WtYzK8oiH3IRFd4uJ2ppRED4KItcxIKPnkDBDkbdpUdFODupsCuNlMiVzSB6GdNurLiwoVVZOZiyZT2rIipceyJGx+FX1NNi4bBYlP2UI6NQqqDvJYSQZpjB/+4e03TYW8cEQQQ/oKq3isgjAFwjIp9R1evmaXDuSQkR2QngOgA7XHvvUNWL5m2XEEISPq0rhf6XELII6Hurof8lhCyCKf3v7aq6p2T7rQBODD6f4MosmwMisgLgoQDuKKurqv71NhF5J9K0jrkmJeqYCl8H8AxV/U4ATwZwpoh8bw3tEkI6TKpA3Iv+6yj0v4SQWpnW99L/0v8SQuphAfe+NwA4RUROFpE1pMKV+8Zs9gE4x73/cQDvV1V15We71TlOBnAKgH8VkcNF5EgAEJHDAZwB4JPz7vvckRJu0Pe5j6vur47VxAkhnaZ2BeIrADwHwG2q+sQJNqcB+GOkfux2VX1abQNYALP431TospdLF7DEJX2qxiYsocsgVcOnOORSOnx75cKZ/n04Fp9GEdoNMruwjzgBy4GRDuLTJ6pELYdWSkdSTOnwB9wSsDTTN4y6OaFLIwUjKzOELs2y2FSNIEXEqitWSoCObZvU73gb4+2Ulfm6kzdVM8+diBgfSkUwMdpRQ3c035w7D0L3ZtQVo3JpSkdt7pLpGzHw/pcQUj/1+l+nEXEBgKsB9AFcoaqfEpFLANyoqvsAvB7Am5yQ5UGkExdwdm9HKoo5APDLqjoUkWMBvNOlIK4A+AtV/ft5x1qLpoRbbuTDAB4L4DWq+qE62iWEdJcFKBBfCeAyAG+0NorIUQD+FMCZqvoVlyfXeuh/CSF1wtU34qH/JYTUySL8r6peBeCqsbKXBe8PAfiJCXVfAeAVY2U3A/jOWgeJmiYl3HqlT3Y39e8UkSeqai6MQ0TOB3A+ADzy+D7uTlYr270rOSyq/zuGR0TZHRwcHmV312Zcv3dv7oqyu3djZ5zd+o4ou/sOxdltrMd9vYNIO12P+5HIZqxd3DOwXqSdJNU2ACDDahsAjT3viJ0g1V7ccdHVuB1JIr2Bri0v13horrc3G6p6nYicVGLyUwD+SlW/4uxvq63zBTKt/z3u+D6GEGxUCF36i6IpdFmx/KePaMhFRSRF4czNpCh+6dse5OoWBSx9H5aoZVjXErD0dULByTJRy2EQiTASuixGQNjLf4YREMV+vZhlWAZjmVAzKsL7vLqjIgI7O1LCELocbzd4b/6KIyMmpha8nAIziiHruLzMiFfIIiBM8Utr+c9w34y62VfTGxmWRk9YIqczUqfv3c5U+d/Q9+46Nu5elRDSbbrqf2udilHVuwB8AMCZxra9qrpHVfccfQxn4Akh5aSrREyVV7dbRG4M/s6fsstvBXC0iFwrIh8WkZ+rf68WR6z/PYr+lxBSwrS+t8OaEhmT/G/oe9eOinuQRQjpLjPc+24b6lh94+EANlX1LhHZBeBZAF4598gIIZ0nmS6vrkqBuIoVAN8N4HQAuwB8UESuV9XPzdHmQqH/JYQsgil9byeh/yWELIKu+t860jeOA/AGl1fXA/B2Vf2bGtolhHQYr0C8RA4AuENV7wdwv4hchzRnrrWTEpjB/yrECV0WUzCsVA2/DbDTMvx3FNptmsKUk1M1cqKWLlUjDF/06RabhqhlTiTTELUcZikdRpmZqlEuaun7ywtY9gplPvUil6qhPi0DRbvEiNsP0y2s0HwtlollZ6R5ZOluuTSPYpmZqmGliIxvC95XpnmUlQXUnspRFiFrpWBY28NtZk6HLwsVLK0+0srhvWhWJTyHesWcGJ/Sob16DlADvnerwvtfQkitdNn/1rH6xscBPKWGsRBCSIZClp1X924Al7k1mtcAPBXAHy1zANNC/0sIqZsGfO+WhP6XEFI3Xfa/tQhdEkLIIqhTgVhE3gLgNKTaEwcAXIR0CTeo6mtV9dMi8vcAPo702fLl44KR24VU6LKf+wzYy3+Gy3pmQpcVy39aURGJIaY5MEQjraU+/QXaFLVMQoHNYmSDr5MrM5b/HNWdXtQyMaIdEi2W+Sfp5vKfOQFLK9rBipRIX6RCEDNWwNKMsrDEKk0xzWJZqXBl1dKhFnUEAhgBC7kuzCgHa0eMRvzhs/qwlgnN1TWOvRU9USJ0mW2r4YaWq28QQkgzdNX/clKCENJKVFH3Ws0viLB5NYBX19YpIYRsMer2vYQQQuLosv/lpAQhpKVI9nSdEELIsqDvJYSQZuiu/+WkBCGklSi6O1u8SBSpAGUoQumP89AoywldGsKUpvil0Z4XqcynajhhSrO9MN2iWNeXWSkd4QXdFLU00jyGhjDltKKW4fhMAcusDxTK8ukbvpFiWoaYdqMiKwXDFLWMTdVwdSuFLk3hyhKRTJSXlaZyzJLGEXuPVyZSaaRl5DIlxDiAJWkelWKaPeM7cqka+RQRKY5lDuh7CSGkGbrsfzkpQQhpLV1VICaEkCah7yWEkGboqv9tZFJiiB7u0R2VdncND49q7+7hrii7ewY7o+zu2oxr7671yH43qvcVAO5fX4uyWz+0GmU3WO9XGwFApJ2sx/1I+utxj2t6m1Fm6G3GtSfDuPZi7WoRVZuB2AlSjfx6k7jTBb1Iu2SwHGepkNyTZ1IP6kQuc8KUTuAyFFfKBCyD72DDLx1q2M2y/GdSutRnUawyjHbw0RD5CAjDzkdFBPsxWv6zGAER2mkWKTG9qKUlYDkqwwhr+U+jzF7q00Ui5OrCKCuxC4qmjooIlxgtEbqsXBJ02kiJSe0UGolsokKY0mrP0JvMIirEsMvtkBEp4U/3nPhlUrTLGgyX//Rva3LN9L2EENIMXfa/3ZyKIYRsCYboRf8RQgiph2l8b4z/FZErROQ2ETFXNBKR00TkbhH5mPt7WbDtTBH5rIjsF5ELa9xNQghpHV2992X6BiGklXjtA0IIIctjQb73SgCXAXhjic0/qupzwgIR6QN4DYBnATgA4AYR2aeqN9U9QEIIaZou3/tyUoIQ0lIkl2JAakLTC14oYOnTHjbMdItA6NKFFObTMoplPrUiL0zZK5RtarHMp0+EApZJVhakebj21OhjaIhaai59o5iWMSxL1Qgj5acVtbSEKQ27HD6NwqibK7NSNXxKRy7Nw9lZfVSlaljtlaZ0FO0q0zdKiE7jsIitO4sIZrRYpd9m5IiIkYJRkdKRpY2E55+38yfq3KmH9fteVb1ORE6aoeqpAPar6s0AICJvBXAWAE5KEEIaZTFpFt299+WkBCGklXR5tpgQQpqiQd/7fSLybwC+CuA3VPVTAI4HcEtgcwDAU5sYHCGELJou3/tyUoIQ0lq6Olu8SBTpcQ2PrRe4tMQq86KWK0W7xIlfmsuJFiMv5ln+MzHEKsOIikyY0hS1LNqFopbWUp9JFlFRFL+cSdTSWv7TWurTP+m2hC5zZd5ejLLAzhS/NOxioyJK+qh6Sl9mN09ExUxYYpW+WysCQo0yo72ccKYRATGKlAgKe+MVgv7C+1Mxyrx4c88a1GzM4Ht3i8iNwee9qrp3ivofAfBoVb1PRH4YwLsAnDLtIAghZKvT1XtfTkoQQlqJqnR2tpgQQppiRt97u6rumb1PvSd4f5WI/KmI7AZwK4ATA9MTXBkhhGw7unzvy0kJQkhrGXbUMRNCSJMs2/eKyCMBfENVVURORRoLcgeAuwCcIiInI52MOBvATy11cIQQskS6eu/LSQlCSCtRjAQTSX0oBJu6krvobRipGkNLhNJ9H/nUD8m9AqO0DSsFI0yZGGgxbcSXDULBSde2VWaJaebSMnyqRpAeMTREMq1UjUzo0kj9yIXyTytqaaRMWGkeplhlVUrHeP9hO0ZZpXBmrKjl+LawPSsdBBV2FnWnchjuJROStOwMrUozzaMktQNAkKoRduzLjJSOUGm1N2YflKmRVjMLi/C9IvIWAKchTfM4AOAiAKsAoKqvBfDjAH5JRAYAHgRwtqoqgIGIXADgagB9AFc4rQlCCGmU3lxKzDZdvvflpAQhpKVIZ2eLCSGkOer3var6gortlyFdMtTadhWAq2odECGEtJLu3vs2Mikx1B7uGh5WaXfvcGdUe3cPqtsCgHsGu6Ls7tvcEWX3wOZanN16nN36etzXMVjvVxsBQKRd78G4k7+3Hjdz14+0621EmaE3iLTbjLOTYbUNMMVSdDUvO6eRX28Sa7ca13GyGteexP085iZVIO7mbPGiGUIycUsgFJysWhLUlSXF5UQ3k1DAcvIyoYPArmz5z1z0ROTyn/6nmFsSNFvWsxg9YQlY5sqMfv3T6JzQpRGJEC1qaURUiBEVUVZXcpEXeft8WYUgZqSAZWxZbKREtMBlHQ+lKlyKGNuzw2YtzRm5TGhOI3No2JVFT/SK55D2Ri3K2Jt5vSZ9LyGENEOX/S8jJQghrWWIbs4WE0JIk9D3EkJIM3TV/3JSghDSShTS2dliQghpCvpeQghphi77X05KEEJaS9LR2eJFoi5fccNI1RgaaRShqKV/b4lahjP7I6HLoMylbYR1fSpHYqRWWCkdYZlPqQhFLW0By6L45ShVI+gjE6Es2mmQRqGmqKWRqjGtqGVOwHKsDZSnVuTSPMyUDkMQs0T8MjpVI7ZuyLR2BrNoi5Xe45WlbKCYHgGM0jYqhS6NNI9MKzVwbz6lI1eWqWkG7WXbwwY1v62GNBf6XkIIKWdRkwdd9b+clCCEtBLV/D+ShBBCFg99LyGENEOX/S8nJQghraXOWWgRuQLAcwDcpqpPLLH7HgAfRLok3TtqG0CLSNDLRTEMs6iIMNohvTzkox1WnL0lTGkISaJYlluu01rW01hO1Fqe1AtdJkakRLj8Z1ISFRGutOgjH5JcpER+W+59RVTEXKKWVvREWXSCsUyoLZIZ2uW35dqbJyoiUuiyLnFL0ciwAEvBMttWbm66oXmiIrxdeP757eH3ZkRjZG9z0RNWSMV8dDV8mBBCmqar/peTEoSQVpLm1dUawnYl0iXn3jjJQET6AF4J4D11dkwIIVuFBfheQgghEXTZ/3JSghDSShTAZo2OWVWvE5GTKsz+K4C/BPA9tXVMCCFbiLp9LyGEkDi67H/nnpQQkRORPnk8Fumx3KuqfzJvu4SQrrPc2WIROR7A8wA8HVtkUmIW/+uFLu1UjaKoZSh06dMtNg2RzLDMf29e3DKsOwjLdHLZMCmmiIRlPlA9b+e2GakkYZS/T99IwrSMTNTSSNUIQynN9A0U7Yy0h2lFLXMpDkaahxj92ukgRntWSkdsqsa0qR9GvyFZCoa5rVg2C2I0XpqWkSuT4raS9I1cuoWVqmGldPjtocuz+jDsNDOrK+S3u0/qYuG9LyGkV9cFKkd3/W8dkRIDAP9dVT8iIkcC+LCIXKOqN9XQNiGkwyTT3WTvFpEbg897VXXvFPX/GMCLVTWRsvzzdkH/SwipnSl9bxeh7yWELISu+t+5JyVU9WsAvube3ysinwZwPICJjjmB4IFkR2Xb9yY7o8Zw37C6LQC4f7BWq92Dm6tRdhubcYd5sBH5daz3q20A9A7FzbT11+NO/v6hOLveepQZ+rF2G3F2vc24GUu/9FqlXVJtAyBaWyx64jPSbrga930kcacpkrjTPiciuEhmUCC+XVX3zNHlHgBvdRMSuwH8sIgMVPVdc7S5UGbxv4o0+iG3lKZfEhRh1IGPdhj5JUtw0hS6NAQs7SVBe1FlwxJRy1mW/xxFRRTLcr9na/lP8+m/seSmuSRo/jXsozJiwYyUMPotq1sVKVEWATFT9ERkBMS04pc1Yc09Wi5H3MDs5T+LKpRzCV1ay39K0c68Plnn5gx0Wf09lll8r0Uv+kaDENIFuux/a9WUcPnaTwHwoTrbJYR0k2WGsKnqyf69iFwJ4G/aPCExDv0vIaQuuho+PAv0vYSQOumq/61tUkJEjkAqEPdrqnqPsf18AOcDwO5HRT6SJYR0llSBuL7ZYhF5C4DTkKZ5HABwEYBVAFDV19bWUQPQ/xJC6qJu37udmcb37jr2iCWPjhCy1eiy/61lUkJEVpE65Ter6l9ZNi63ey8APOZJhy8wIJMQsl2oM69OVV8whe25tXW8YKb1vyc/6Qjd1BUkuVQNn24xKvMCl+F34N8PK+paqRpmmoeRDqKmnevXTBtBoSyf0lEUuvTpGLkMAs1vy9Ux0i1gpHSIIX4pVurHHKKWdh9FOysFo0r80qwbW2akaswnflksqz2Vo0zo0kzjCIaSpWpooSxXt+fSc2YRurTK/Kaw7rBYNi9dzWmehml971GPe0ThDPY+kGkchBBPV/1vHatvCIDXA/i0qv7h/EMihJD0fryrs8Wx0P8SQuqGvrca+l5CyCLosv+tI1Li+wH8LIBPiMjHXNlvqepVNbRNCOkwXc2rm4Lp/a8TURrmoiImL+uZszMiG3wdKyoiF9mQLQnaiyqzlgRVK6LCWCbUWupzruU/zbJRkS1qaYlfutcqIclYUUtLODN2qc956lpRESVimpWREuPbYrbPSNUyoGLZGadBFjVhil+GHTqRzF4QHVMmdDlhXIVNVl3rO5gR+t5KeO9LCFkIdftfETkTwJ8A6AO4XFUvHdu+A+kSx98N4A4Az1fVL7ltLwFwHoAhgF9R1atj2pyFOlbf+CeUXjoJIWQGtLt5dbHQ/xJCaoe+txL6XkLIQqjZ/4pIH8BrADwLwAEAN4jIvrHli88DcKeqPlZEzgbwSgDPF5EnADgbwLcDeBSA94rIt7o6VW1OTa2rbxBCSF0ouptXRwghTUHfSwghzbAA/3sqgP2qejMAiMhbAZyF/PLFZwG42L1/B4DLXIraWQDeqqrrAL4oIvtde4hoc2o4KUEIaS18Wlc/6QWvNyZW6VI1ggthlqoRlGWpGoZYpZ2qEaaDFAUxTWFKQ+hyaJUlhiCmS+WwhC5hpH7kUgS8+KUpTIkihjClLX45KrJSMGy7MfugTqWoZe12c6RqlNkFlKd0GIWzpCdI7iXfnBRLbVHLYlll+oY73cP9GAldBikd2cagj97YtmB7TuhyrK86oO9dDhS4JISMU7P/PR7ALcHnAwCeOslGVQcicjeAh7ny68fqHu/eV7U5NZyUIIS0ki6L/RBCSFPQ9xJCSDPM4H93i8iNwee9btWfLUcjkxKJ9nB/sqPS7r7hzqj2HhyuRtk9MFiLa28zrr1Dm3GHb3OzX20EQDfiHnPIRtzJ2luPs+sfirWLMou3W4973NVfj2xvI6693iCuvbofYMT6GI07XdCLO02RxJ32GA5jBxhnVge8MV4EqchlLurAL/+phuCkEdmQi7Iw6maRDdaSoEGZF7gMy7zApbVMqCl0mStzfRnLelp25vKfRvREXugyfbGW+rSjDoy6lUtuziFqWRYBYQhYmsuEBuusmnZlZUZUhF2m5XZj2yYRK+pY5krMZT1z2/22olhlzt7/BHJCl2PbctuLxwA9YwDhPlrLgxrdzgt97+JgdAQhpIwp/e/tqrqnZPutAE4MPp/gyiybAyKyAuChSAUvy+pWtTk1lFcmhLQSRSr2E/tHCCFkfqb1vfS/hBBSDwu4970BwCkicrKIrCEVrtw3ZrMPwDnu/Y8DeL+qqis/W0R2iMjJAE4B8K+RbU4N0zcIIa2FYmuEELJ86HsJIaQZ6vS/TiPiAgBXI12+8wpV/ZSIXALgRlXdB+D1AN7khCwPIp1kgLN7O1IBywGAX1bVIQBYbc47Vk5KEELaiTKEeBEo0vQLU+gyl4JRTKMoE6EcaLG9qrpWCkYmfhmMOUsbSQy7ijSPkaqgIWBp2VlCl2FqRWYXlGVpHuGgxW0L7DL70G6sjaCdecQq7T6q2tPp+rXSMnIpIoZIpnlMUaQspcPCEsQM0y2sKqWpGmGhf1WjLOjD766V0mGkYITNjX4+YaHk26hAC29mhL6XEEKaYQH+V1WvAnDVWNnLgveHAPzEhLqvAPCKmDbnhZMShJBWQrE1QghZPvS9hBDSDF32v5yUIIS0lq465mWQE6b0YpWhMKUXukRo1yvUNZcENSIgBtZyoijajaIiRn2YQpfZtmCf/LKeYZkWy9SwgxERMIqysOws8ctRkVhP+ktELauiE+YStTTtilERU0doVC0dGiuImW0rCmzmtxtlpZRXMFYCDZb/FKPMsjNEMsOlPo0lPEuX9cxFVKgrKo/4WAT0vYRsfcJr9XYWWPX7WbWPsXZN01X/y0kJQkgr8WI/hBBClscifK+IXAHgOQBuU9UnGtt/GsCLkc673Avgl1T139y2L7myIYBBhdI8IYRsWbp878tJCUJIa9GOOmZCCGmSBfjeKwFcBuCNE7Z/EcDTVPVOEfkhAHsBPDXY/nRVvb3uQRFCSNvo6r0vJyUIIa2FCvCLIVHJUjbSz0UlvVKhSxhlYUpHSVqGKWpppGXk7Ywyl95hCV2aApZWWkZi2JmCkxUilJZwZqwwpZXiEGk3rahllmJRVbdizKNjUEy3qEzVcCkapkimURYilpjllKiVsyHFtxoMxhK/9OkduZ+OT+kIxpltDytbwpVasi04GD6Vo9Qzzn+Yave9qnqdiJxUsv1fgo/XI133nhAyB21PU6iL2P3cKsejq/e+nJQghLQSpQI8IYQsnRb43vMA/F3wWQG8R1IBj9ep6t5mhkUIIYulBf63MRqZlEggeCDZUWl3KFmNau/BYaTdIM5ufRB3WDY3+1F2yWbkel6Rdr3NuJO1txHXbW89zq4fa3co7jHNyqG49lYi2+tvxNn1Iu3Cp4ClxD6VijwNkpXI73ctzm44jHRu0RPIy3OWXQ1hWyQKwRC9vNClsSSoFdkwso8Tq0yM9tSwGyTldpnQZbgfCsMu30bOLimWWUKSOUw7K/Iifalc/tOKvIgWkpxsN4uoZXRdKyqiBvHLfFnRrtBXyByRAGIoaFrRDjlVSxl7BQIFy7BtI3oii4AI+5VcE4U6pVSLX9bhNWfwvbtF5Mbg895ZJg9E5OlIJyV+ICj+AVW9VUQeAeAaEfmMql43bduEEDIvvcBxL2ryoKv3voyUIIS0lO6K/RBCSHPM5Htvn1eAUkS+A8DlAH5IVe/w5ap6q3u9TUTeCeBUAJyUIIRsQ7p778tJCUJIa+nqbDEhhDTJsn2viHwLgL8C8LOq+rmg/HAAPVW9170/A8AlSx0cIYQska7e+3JSghDSShT1hsbNsyTddiPRXk7oMisPyoYu32iIXq5e+ArkUzlGdiWCmAjTKKy0DJ/6MSoblohaqplaURSmtMUvwzSKYlqGmGXutcLOTssw2rMEImGUlQpOGuOLFbWMTf2oFL80UkSsVA0jlaRU1LIsrWYaLFfihSmDsXghzDDNw5/uIkW7XFqekdKBXrFjv2/5lI1pfd2U4pdTtryAJUHfAuA0pGkeBwBcBGAVAFT1tQBeBuBhAP7UpcH4pT+PBfBOV7YC4C9U9e9rHRwh25TwWl0m8hhrZ9WZ1n4RY1kmi45iWIT/3SpwUoIQ0k507B/O+bkS8y1JRwgh25/6fS9U9QUV218I4IVG+c0AvrPe0RBCSEtZgP/dKnBSghDSWupcFolL0qUogCHEXMLTEroMsUUte7lt4XazDUPo0tpuLRNqR0qUR0+YERVGFEOhs+C9tSSouXRoRQRE2fKfpoBl1XKiJeKSM4laRkZZxItfTo6KyC3vaYpf+rLyuzNDt9LEfPBkLg/qBxgUJb6NoLBfjCBRHxWRa9bbBedp6bKfs/g8zY+vhUuCEtJFYqMJprULaWM0QV0s6vjVZbcouup/OSlBCGklikbz6saXpCOEkE7QsO8lhJDO0mX/y0kJQkhLmVqBeJFL0hFCSEforvo7IYQ0S3f9LyclCCGtZcq8uoUtSbe9kEII6DATsCxPwfCillZooZnSYaRWVPVhpWWMthXfa5BGoYU3wXtT6LJoZ6ZqWGkZZh9BWZbOIEZZeXtlqR9mmkeF+OXUopaxKR1WqsbQGEv4xRl1M5HM3PEr/vhLUzWsbWK+HVXxDfYMwyBVw3+FofhlpmkZ1tVieyO7cIBlN5yxdoaZccxmpas5zYTUSWz4fx12vcA/+Wtq3ekHVvpI3cwy5qaPc9101f9yUoIQ0lqWGcI2aUk6QgjpGl0NHyaEkKbpqv+tZVKiaqm9cRIIDml11+tJ3PAODVej7DaSfpTdYBg3EzgcxLWnm3HtyWbcSdir3S7KDL31OLuVQ5F2D8ZNBa4cipvZ7MfarcfZySDSLlZozVgaziJZiztfejsiz6uk5pntxU+UA0hniut0zHMsSddapvW9IUNL6NL4cnOCmO79sCLawYykQJyApX/YWxU9YZ4bVpRFSVSEvXRosb18BETJsp6RZfZYwj4ml9lLglYJThbrRotaThs9ET6tt6I2jKgIGWrOPsQUxJwHIyhCw33LVosN9s357tzp4sry43NlwTHQ7DYhPF9jRS0n24VjqVuLrW7fu12Zx/8SUkXPuLm0nsxbdrHt1hFRsYwlPOc5FlXRDL5OtV3i7PpBWf0hDV32v3VFSlyJ8qX2CCFkauoMjZt1SbqWcyXoewkhNdPVnOYpuRL0v4SQmumq/61lUqJqqT1CCJmFrubVxULfSwhZBPS91dD/EkIWQVf979I0JUTkfADnA8BRx+1cVreEkC1MV0PY6mbc/w4hletg+1SO0M6avffbzW0VaR6WXZaqEWy30zcwsSysbJXZaQLTpWVUpmD49ipEKMtELSvLfGpFVapGWd15UjqGxbJ82khcqkaWAmGVWdHA89yxBQKWPltJgo7VbQ/Nsu7ClAlL6DL7gnMd5rdVllkY40uKW6VoPjP0vfUQ+t5dxx7R8GjIViL2afkoBcNKXSimVtjX4MWlYEwrjmnbx41plgiD+OO8pNxldNf/Lu0Iq+peVd2jqnsOP2ZtWd0SQrYoCoFq/B+ZDP0vISSWaX0v/e9kQt+7dtSupodDCGk5Xb735eobhJDW0tEItsWixRn/siVBLfLil5MjH7SiPcuubCnQ3ANyI6KifPnPusQv05dwlKWRDVURGiXClFVltpCkMZZsGc6aRC2HRpkldGm154Uuc3Z+7EF7WizLmMUxWGEESVHAMouQCH8iOrZtwrC8XRg9IcU4hmAMceKXlaKW/nSu0WHS9xIyP/5aWRV9YD2Ft+qU2VnLcs9C7JjnoY4+Yo/ZLP3G2/n1okvNpqar/peTEoSQdtJhBWJCCGkM+l5CCGmGDvvfWtI33FJ7HwTwbSJyQETOq6NdQkjH0Sn+Ogh9LyFkIUzje+l/6X8JIfXRUd9b1+obpUvtEULILCRJN2eLY5nH9w6NFAwrxWIYhoSWiloa7RkxjZaoZWJcWK2UDvPpgWkXbh97hbEteG+mW0SmdFTZjdIo4vq1y4opE9WpH1YaRX5bbnyRopa2nRbKcmPJhC6NVI1wLFYugiGcGYv54MmnWYR5Gb7x0Pf0xl5zDaNol9vshCmjhS7LRS3NXJKxCOM6vCZ9bzW89yVVxKYn1GGXF7qMs7Ou5YtM2xjvwxqL1b8l4lklfunrhPtY//exmFmBrvpfpm8QQlqJorshbIQQ0hT0vYQQ0gxd9r+NTEqoCjaT6q43ImwAYGMYZ7c57EfZDZK4rJbomaxhnJ0MYu3iuu1t1mvX34ybEexvxNmtrMfNRK48GGl3f9yB6a3H2clG5IGOpRd5Xu2MO58l8ryPRWPH11+Ss1RMeLxJ5kEhGGqvcknQJBO/LD8vrKgI6+mLtdTnfOKXJVERMMrMqIOKyAYjYsFcdrE0yqJkTGHdCrHKeZYTLRe/NMpmELX0ERB5O/c+jJ4oi4pIDLvwCzajJ4pFFuJP41yEgRtzUJZpoPZH570fX3geZscyd1thRUD4kjjxS5WwD8POvw2OVVan7JybBvpeQhZOdcRC8Ycca1fVX7GsPDphlqU2p8WKbIixD+uU72PV8qnl/WbRE2FUaN0Kl0Cn/S8jJQghraVONXlCCCFx0PcSQkgzdNX/clKCENJeOuqYCSGkUeh7CSGkGTrqfzkpQQhpKdLZvLplM3QKfcOKBZmGkaka1rYyMc1cqkZWVmwvF8lfeBMaSvG9KZJp1KlKwbBSOmJTP6asmy8rikbCFLUcsw/K8vthiV/OL2oZpm+gLKXDStVIgk6M/Sh9fGRts8Qgc6ka7n0vGIsXl9TRWLRvnBulP5ViWkZuqIb4pfYsUUujOR9BHGZ0JIbdXND3ErJolpESETuGME3Tpykscny+v154sZnSLnZ8ZWmiadttmwHorv/lpAQhpL207VpBCCFdgL6XEEKaoaP+l5MShJB2ot1VIF40iRO7rLIBxqMdJtexl/os//5Kl/rM2fk3RgREzrAk2gFGmRWdENveHFEWs5SZwpSRAptmhIYVZeFFLY2QlJlELY3oCWtJ0CyiwoqKGIY7Z4yvFCNKIRSS9KdzKFrttmsg6JsJovaCc9yFSlR7qBLxy3As2YPA8Atx2w1Ry1xEhbWM6TzQ9xJSC6Mn/eWKvPa1tVinDjtT5DH0ZLFjdnV6kf9Bh31YdayojfFt+bK4Y2HVCfetrO28nRP/XoS4ZUiH/S8nJQgh7aWjs8WEENIo9L2EENIMHfW/nJQghLSYbs4WE0JIs9D3EkJIM3TT/3JSghDSXjo6W7xsykQoy+zT9+VpION1qlM1inZldfJ2/k35WMRKt8i2Fd+bvcemUVhtRwtiGsqeluimJVaZWHZFccmcMGUmOBm0ZwlTTilqGQpiejHLXJmRqjES9jTsEuPgVuGFJMMyn+4Qil/2vdBlUNazUjXS/dBA8bL8zA62Zmkj4Xb/hYSpJGlZLs0jKdrFnvdTQd9LyNxUpUDUYWcLNU62s+x7gZ/1fZhpHnP4hTBlw+rDvx8Yh6JqH637EF8nL2o5//cR7sfCUjk66n85KUEIaS8ddcyEENIo9L2EENIMHfW/jUxKKIBN7VfabSbVNgAwiHxSN4x8CjgcxrWnsaJSkXaRE3iQYb3t9QaRdpuxdnG/pt56nF3/wfIlg7L2HogbYO+B9Sg7Wd+Isitdpi6kH3c+Y7Azzi6SULCtjGQt0i7y+50bhS1mSOZCgUqRS2DO5T8RFxUxegi/uKgIM8Ig1q4k2iE2KsJ6wFMlTFkqxFlRZi5Z6g+0UWYu9ZkTv5wceREtahks9VlalhO/TIplVvRELEZURPY+ELD0ERI+OgIApDQqIlg6tEz8Mix0l7TcqV4ilmqdL5r7LpE3nNdF0/cS0jh2pIIUtsUuaVkaKRE4eMuu9NqfE7CcDnss5WWjiIqwt8nRHdZ+lB3byWP1S6UGy6cuYvZgif5XRI4B8DYAJwH4EoCfVNU7DbtzAPy2+/i7qvoGV/7dAK4EsAvAVQB+VVVVRC4G8IsAvunq/JaqXlU1nmnPH0IIWRqq8X9ViMgVInKbiHxywnYRkf8lIvtF5OMi8l117w8hhGwFpvG9i/a/InKOiHze/Z1T314SQkj7qNP3VnAhgPep6ikA3uc+53ATFxcBeCqAUwFcJCJHu81/hnTy4RT3d2ZQ9Y9U9cnur3JCAuCkBCGkzegUf9VcibzDHOeHMHKs5yN1toQQ0j2m8b0L9L8VN8SEELL9qNf3lnEWgDe4928A8KOGzbMBXKOqB10UxTUAzhSR4wA8RFWvV1UF8MYJ9aOhpgQhpL3UGMKmqteJyEklJmcBeKNzrteLyFEicpyqfq22QbSIvFjl5PXBK+tGCj35a2esmKaZqlFZSfKvVYMJ7cr6MMLno+1iy4x2rLB9uyxImTD6KE05sdqrEMTMUjpyKQSa2wbAFrUsKctSNgAzVUOGRk5i7MkhxfQN9WkbYYqlIWo5SsuoStUopnl4gzD9xQtX5o6BH1dilAUHOqtrfG81PDULB1ljY7P7XwCnwd0QA4CIXIN0cuMttQ6QkC2EdR2tSrcoS1nIpSTI5JRpK50z32/PlRV9de5eIeuvPD3b7mN+35QXv6zTcdbEdPu4W0RuDD7vVdW9kXWPDe5xvw7gWMPmeAC3BJ8PuLLj3fvxcs8FIvJzAG4E8N+ttJBxOClBCGktS75WTHK823JSghBCJtHAfXrZja9VTggh25Ip/e/tqrpnYlsi7wXwSGPTS8MPTguiLs//ZwBejnTK/OUA/gDAL1RV4qQEIaSdTB+aNs9sMRnDP/GIFQi2Ii+qyJb/zJWV2FsfKqMiJgsIltrn+pjDLlcnfakSvxwthzm5jVydyIiKvNClfzWiLIxlQvPLk2rRLlMtjRS1DMqyCImcXYnQZWKUWYhxbuRELXsFO6s1ybZViF/6dsIx+d0Il/XMwk+C8bl9Cu3KBE81d1yM6Il5mC0smP6XkDHKIgcsu7HSqeyqlur2S22GkQEDt6BAuGBAT8uWBC2/zq/0ipEPPkIiZ58FhhXbGwSLHGTRFcbhs/YxvDRYwpQ2k49z+L3FRpLOTT1pGaPmVJ85aZuIfMNHBLvItNsMs1uRRqx5TgBwrSs/Yaz8VtfnN4I+/hzA38SMlZMShJCWItOGsJXOFkdwK4ATg8+ZgyWEkO4wte8FFud/J90QE0LINmQm/zsr+wCcA+BS9/puw+ZqAL8XaPmcAeAlqnpQRO4Rke8F8CEAPwfgfwPAWOrz8wCYAsfjUOiSENJelif2A6TO+eecCvz3Arh7u+pJEEJIKdP43sX636sBnCEiR7ub4jNcGSGEbE+W53svBfAsEfk8gGe6zxCRPSJyOQA4PZ+XA7jB/V3iNX4A/BcAlwPYD+ALAP7Olb9KRD4hIh8H8HQAvx4zGEZKEELaS40hbCLyFqRP3HaLyAGkiu6rAKCqr0W6xvIPI3WuDwD4+fp6bxcJBMMZ5qTNMMwy+xlSOjy5qPzYurFpFI58ykRcnbIUjFn6KEvBqOy3tL1iWkY+BcPqV4tjztIyimU5gU3DLlrUMrMrlpnil4kRy2ulcYSpEE7AMncu+TH3w7QMZ1ZszRa/DEUo/X4Evy01UjpGKRjFsUiQXjLa31CcM99GONh6hS5rbAuz+1/3NM7fEAP5G2JCWk1V2sYy+1/pTU7L8CkbALCzPwAA7HCvALDpUirC6/hGslJoz7/PlTnHFKZl+DSPNSPd41Dw3texxSiLqRXW8bZSMJr+Xiqp2f9O7Eb1DgCnG+U3Anhh8PkKAFdMsHuiUf6zs4yHkxKEkPZSb17dCyq2K4Bfrq9HQgjZotR8UzyP/510Q0wIIduSJU1KtI3GJiVilpGb5WlcGVqzXW4ZsRKkdrsoM5Ss6jPWXtzZH9ueMfFp223G7UhvM67B3vpmlJ08cKjaCIDed3+UHYaRO7xrZ5RZ7klZCb2VuCfdvR39aiMAvc249mLPg7lRLDOvrtPMEjXhmT4CQsz3cZVnryuR9rkoAaOsrE505IUV7VAW9RC+r7ArjeTItWdERZjCisZjeN9HGAHh2wujGPzbWFFLyy7wrz4SAdY1K3jSBzHOZ/eUUMLoiX4/N/a0zO1H2HSxtawdDccsrr3goGbHz1oStBceP9eeIWBpfR/W+Z+dh8Z4p4K+l5ClEvvk3o4EKEYnJFosWxEjUsJwlbv66b10GCnh6x4ajv5tNCMuXNlKGJ1gCA77qA3fV4gtoFnc70ESDj5OnHO+4xwrnDknHfa/tRxZETlTRD4rIvtF5MI62iSEENH4v65C/0sIqZtpfG9X/S99LyFkEXTV9849KSEifQCvAfBDAJ4A4AUi8oR52yWEkCULrW056H8JIQthGt/bQf9L30sIWRgd9b11pG+cCmC/qt4MACLyVgBnAbiphrYJIYRMplb/G6bVzZOWscyUjrwgZmylKe0DytIoSvuaok5sH6PUCqOuMYZcRKplZwhY+rSDfJqHkdLh284JOvrUhdAuUtRyMHDNBXV9KkeuX3NHikUuLU57o3S27EwLw4v9++BgZeKXoZ0fswTtuTraC573+PGFdbPjF5Y5s2JGTB7Tzn/oZshvQ/DelyyFfFqGFMrqoOqave4EJx8YrI3KXCpHmKqx4vJ7V/qhuGTadih0GdtvGdZxmccuvt+Wi2RuYepI3zgewC3B5wOujBBC5qKrIWxTQP9LCKkdpm9UQt9LCFkIXfW9SxO6FJHzAZwPAA85bteyuiWEbGU6KvZTN/P433lEneZ5KjG1CGau8hx1llG3KrKhpE7VkqB2H8WIipFdGNlQ0q4VnWBGRQR1fDSBtXRoLgLCELX02wcjsbWsX8vOICdqaZxPWXxBP4xsMJ6C+XZyopZFscpsKIbmZjhKa9lWNaIcprXTac/DMuh7ayH0vbuOPaLh0ZC2Yl1nR8KKUrALA8Qsu4G6pTQDZzAwhC4PDVeNftPtm8GY7to4DABw56HR/cNgmPaxa3UkVnnkWiokH4pkDlx0RSiSOQwiLsb7DQUs/bKjK4HvLROctI9L+T3MtJEPZd9VbXTU/9YRKXErgBODzye4shyquldV96jqnsOPLp6MhBCSIzafzv91E/pfQki9TOt7u+l/p/a9a0fxgRwhpIIO+946JiVuAHCKiJwsImsAzgawr4Z2CSFdp6OOeQrofwkh9dPhG+NI6HsJIYuho7537vQNVR2IyAUArgbQB3CFqn5q7pERQjrPdsuXq5tZ/K9CMJwxJaOpdAxftyRSv6Ty2GtL6+bEJafsL5/SEVnZSgcx7YqpH7aYprpt5Wke2ftQ1NKVaZge4VM0wlQNXycp1rXSLnLD7KehxhLG964W7bKUD0OYMqyrPWPfXGpFeAzUOC5ZCkYuzcMfg6C5npGq4TNialnQfTL0veXw3pdMwyxpkLF1yuxC8WoYqR/+mr7WG/nZXf3N3CswSqPY0d+ZlR3m0ja+5Yg7s7LvOvIrAIBjV+/Kyg5sPAwA8In7RpIrX3vgIQDy4pcrbgw+9aRqP6ztYbpKHcevKbrqf2vRlFDVqwBcVUdbhBCS0VHHPA30v4SQ2qHvrYS+lxCyEDrqf5cmdBkS+6QuqXl5q9infNEPmmKfgMWZxZ+EdZ+sszzJK7Mzl2iz2ovsdxhpOBhW2wDQjY0ou+SBB+LaW1+PsusbT70sZOeOuH4tQTaL2OMX2dxSZ3A76piXwTxRD/OJX85cNc887cwlojl73al/O1XRCbF9TXltifX1OZ9RVseKlMhFVPgIiKBsaJUN8/YIoifUEqgcnafZsp65zcWoCE28gGVwjlv7VrYsas+wyymw+fcV55K1dOiyoO8lpDbmEUKc5XrbM37A1hhWnA88bGV0X7x77T4AwENXHizY37U+0kXxwpTeHgCeeth+AMBT1kZj/uKOrwIANoMIiHs3d+TayI1JRvfyAxQFOy2qthfs276sZ0f9byOTEoQQUsV2XO6IEELaDn0vIYQ0Q5f9LyclCCHtpaPLIhFCSKPQ9xJCSDN01P9yUoIQ0l46Olu8lZgvDWQLX3jnODfnegoyV7/TV/Zjja5rpGpUpvRlaQqhgGX6XgOhS5+2ocMwfWNo1PWDDs+vVNUyl5ZhCXGO9ZW+d3V65fvhj5Ea4peVGMKj0d9WrGjpNND3EtIK6k41CFMmVpD6z1DU0qdtPLQ/St/4Oh4KADj44GFZ2V33pO+/fPDorOwRa/cAAE7d8YWs7NEr6TLkx62OBDHXeicAsNP0V3qh743ape1HR/0vJyUIIa2lqyFshBDSJPS9hBDSDF31v5yUIIS0l446ZjIFc4lW1jeMmWko4mK+aA1j+c8p686yvquWRFRUtqfGcqKe/Bp56WustlxOwDKyTjamGSIqvLW1xGidtOG3QQiZCUsc00dchMtwejYD+0PJamH7Vx5IoyG+eetRWdlRH0/tjv3nu7OyvWefAQB4+Fl/mZU9ecctAIDbBw/Jyh4YrOXGlL5XN/aRPyvbj21NR/0vJyUIIe2kw2I/hBDSGPS9hBDSDB32v5yUIIS0l446ZkIIaRT6XkIIaYaO+l9OShBC2ktHHTMhpIg44UqVIKTXP1LSoVEjrOzFKqfNsego9L2ELA0rTWGu9oyUrkT77nW0beBEfHubO7KygyuHAwCGgd3X7k1TL1ZvH/3b+JAvDwAA+tFPZWVHPeX7AABv/er3ZGUHdh8DAPjCAw8f9XEoFck8bHUjK1vrF324H2sozun3o1ezk2pVWkhH/S+vzoSQ1uLXa475i2pP5EwR+ayI7BeRC43t3yIiHxCRj4rIx0Xkh+veJ0IIaTvT+N6uhhoTQsgi6KrvbXWkRN2zYHUjTa1m11C/GrnDsXbx/UYaRvYrkU/KZG0tsuNI+kVxIZPYJ3l1n4CxK9ct8/yr0QWISB/AawA8C8ABADeIyD5VvSkw+20Ab1fVPxORJwC4CsBJ9Y2C1E7uqjzlydmGFUnn0emU2ZuYpy6yiIVR7eh2fJ1Y/xX6Q7/8Zy/o1+2IouhfJbDL6lj9WnaxTGsfMocPr/s6W+xgsc0T0lXqjorI2p3Bm6vznxvJ6N/BezZ3pu0FN3sbg9S/auBm7z0h/XDo574vK7v7lPR1ZX1nVvbJex8FALjz0Gg50Y1hWnfXihXRIeZ7TyaIaezvPP83Vn0vS42k6Kj/bfWkBCGkw9Q/C3wqgP2qejMAiMhbAZwFIJyUUABeIvqhAL5a6wgIIaTtbMMncIQQsiXosP/lpAQhpL1M55h3i8iNwee9qro3+Hw8gFuCzwcAPHWsjYsBvEdE/iuAwwE8c6oREELIdqCjN8WEENI4HfW/nJQghLSX6Rzz7aq6Z84eXwDgSlX9AxH5PgBvEpEnqmqLFJDahQ+lrJAZLK1rhWi2nhrSLmZqZq5+w3SLuB9XNtbYumFagU/zCNMtrF9SltIRClj23KZRX+pS4GQ4LJZZj5bCfn36XJgOUprSEWkXoNOmpoSIb2P6qnPVnURHb4oJWTRWGkAdKR1h6kJZakNONLJXFJL041vtjcqO3LkOALhn92ZWds9K+i9kOPTesYcAAEesjQQsDw1WAQCDwHCll/axY2WQle3sp2178U1glFaSG992Frj0dNT/clKCENJKBLWHsN0K4MTg8wmuLOQ8AGcCgKp+UER2AtgN4LZaR0IIIS1lAb6XEEJIBF32v5yUIIS0l3od8w0AThGRk5FORpwN4KfGbL4C4HQAV4rI4wHsBPDNWkfREsInD9Me59yThSmf8IS6gHM9n5jnqXC277M80Z697tTikoHhtHW1GLAQ3V90REX41Se+jmFvRE/kynxUQi84I/quTMvPNVHXn/W0K4x2cP1J2K+PnggiNMQan3UAzf0ommXbezN8ITLtCVMjNd8Ui8iZAP4EQB/A5ap66dj2PwLwdPfxMACPUNWj3LYhgE+4bV9R1efWOzpCmmWep/U94z9YaylNH50QRhqsJKkPXOuNos+OWXsAAHBEf33Ux1GaawMA7n1EKga/a3UU7fAtR94JADh+111Z2bqLdrh9/Yis7NAwLTt67cHCfjw4XB2VDYv7ZkVYbsloyzI4KUEIIS2iZrEfVR2IyAUArkZ6Y3yFqn5KRC4BcKOq7gPw3wH8uYj8ejoCnKuqHb08EEI6Sc2+N2blI1X99cD+vwJ4StDEg6r65PpGRAghLYVCl4QQ0kJqdsyqehXSZT7DspcF728C8P319koIIVuM5a98FPICABfVOgJCCNkqcFKCEEJaRkcd8yIRKPqSYDNccDwSK0w0ut8a6oah99GtydjrVB0vr24uZWLKY5VP1ShJowgxxBHNoWYpBIHgpJVV4EUtw/3oWZ249/0g18EFI0mQbqGJ668/Ok+zVsLzQIt25m74/sRI6QjHkqV0lAt2mukbfkxWXVNM06jTKz9hsgyWRUcr1+t7Y1Y+AgCIyKMBnAzg/UHxTrey0gDApar6rlpHR0gHsIQufTrGSpC+0XeJlTt7I1HL3TvuAwBsHjlyWoPDU195VJCCcezaPQCAI/uHsrKDg8MBjNI40jHsAADs6I9SP4ZZykkxlWWee48tScd218NJCUJIa+nadYgQQtrADL63aknmWM4G8A5VDRf0ebSq3ioijwHwfhH5hKp+YYa2CSGk9XT13reRSQn/pK6K2Jmx2u16kWdDZHsaaxerFxf7hCSyPa14MjOyq3c/kpXIflfjnujqjrjTWXbtjLLr9SJ3ZBi5GOLqarUNAF2LtIs9Lqtx+6H92PMgyqweOuqY28R8opajL3A4pRBVbinIaR8Lh+ax55AV2bCourMIWJYEHVT34UUey0UoNYtIsdoLBR3d+ySs68zCU8SfL0nwXbqoBAmlWvqTBSxzI/ZjCOqKb9tatTccjB9zL4i8yKInDNHNfjGiwlom1IqKyEdAFIel2XdZHqZi2hno+PlXRxTF9L63bEnmmJWPPGcD+OXcUFRvda83i8i1SPUmOClBtg3WkqDxS4eW2Y22+SU5Q6FLv/xmoqP7znsGuwrtrSerE/vfTEY+9b5hGgERRmLetXkYAOD+wY6sbMPVCUUt/T3CoaBs4OzCSA5PXujS7VvF/5Z12MV+V3PR0XvfZf57QQgh8eiUf4QQQuZnWt9b7X+zlY9EZA3pxMO+cSMReRyAowF8MCg7WiSN9RaR3Ug1fyZpURBCyNamw/e+TN8ghLSWroawEUJIkzSw8hGQTla8dWzFo8cDeJ2IJEgfpF0artpBCCHbja7e+841KSEiPwHgYqQXjVNV9cbyGoQQMgUddcwxLML/hmGdWepFbDabFOtGJjbl6o7ex8WgSy5NIbbDqbrIkaUpTNvXFP3F9mGlZdgilG5bmJFgRZv6lIRgm7i0vdy/iVm/YdqDMzBTOopfkgbpEfZurrg+grPI7UDuf9Yp0zdyY/ailmFahh9XKLpZluYRpmr0LDvjCxHrS3JtVJ0vRhpP/Mk4BUte+ch9vtio9y8AnlTvaOaD974kljpC/e2UjYo6zlEkoaB14vsf/bg3ksn/BoapFT71477NUQqGT594YLCWld3v3ofpFj4dI7QrY2M4GlOWcmL49/C4JMZFzh9n6/glM9gtlY7e+857tD8J4D8BuK6GsRBCSA7R+L8OQv9LCFkI0/jeDvpf+l5CyMJYlu8VkWNE5BoR+bx7PXqC3TnO5vMick5Q/goRuUVE7huz3yEibxOR/SLyIRE5KWY8c0VKqOqnXefzNEMIITbdu9mNpk7/65cAG2Dxy4SaURGxIQ65uq5qZPhBKDgsJXXMoVQsm1kQGgze28tsGu8jn5pbX7clfmku9WmIX+buaow+RtEY4Vhc9EQgjis+AiKIMBC/gELF06bo2Bi/dGgSPDXzTVt9WJENljBlKGrp7NQoC+3UFL8s9uvtcoLSvbE2EJ5Dxhdnfm8okAljFjdND33vRHjvS2KJjYoos6tqw7oGrxhxin75z9A+cT46F3XgHMkgKBsJYo7O+aEr2wg7MSIlBknxvsKPwRx7KGqZ5Mcekmi4HzKxPUsI1CL2u1pK9MTy/O+FAN6nqpeKyIXu84tDAxE5BsBFAPa4kX1YRPap6p0A/hrAZQA+P9bueQDuVNXHisjZAF4J4PlVg1laXIqInC8iN4rIjfffuVFdgRDSbTos9lM39L+EkGjqF7rsLKHv3bjrwaaHQwhpO8v1vWcBeIN7/wYAP2rYPBvANap60E1EXAPgTABQ1etV9WsV7b4DwOkSMYtbGSkhIu8F8Ehj00tV9d1V9T1uveq9APCobz+KlzBCSCmCela228rQ/xJClg1972J871GPewR9LyGklCX732ODSYWvAzjWsDkewC3B5wOurIysjhM6vhvAwwDcXlapclJCVZ9ZZUMIIQuh47dwi/K/PWiWsgEAg8igOS+EmQuRLPmOQrvpxS/DD5FpHlMKWJrpEZUDK9Ytq1PVhylqGSlwWJbKIbnUAC1UyFJnDMHEMNUlE4gMQmXVyhMw7DJhyuBck5JzLaelOTYm13H6mvSKZRbWAcqlURRTOtQQuvRpG5or88eq2F6Y1jI6J4spHblj70VGjVSNXLSwcR6Y6UPzQt/Le1/SKFYqgpWmEJtC6e1WwjQFl1kxSEZt+FSJnF0vvy1sLz+WYgqELwv/4fQpGitWyoRxiZg2TXRS3cS4h/DbrW2NMd3u7haRUGx3r5sMBVA+wZrrUlVF5lWpmA8uCUoIaS0dFFAjhJDGoe8lhJBmmNL/3q6qeyZtLJtgFZFviMhxqvo1ETkOwG2G2a0ATgs+nwDg2oox3QrgRAAHRGQFwEMB3FFRZ+4lQZ8H4H8DeDiAvxWRj6nqsyvrAViV6udlsaIj5kybQd8QSrGInSjyS6VVEa2JEtmeoRkzwS5SAC62vcizJVmN6zdZjTswwx1xA5Rh3HJDsciO1WojYLQkXRUrcfuR7Iw70MNYu7W44xz9va0scTaZN8YTmdX/xuL9bz9YVnFQaj99VIT3tbGrG1oRBvmrt1HZiBIofaKcE34sCZ+ItcvVSV+sKAtriUfzWmQ8IbeiLMyIirBuJhBZjETIL+HpRC1zURbuTehasuiJQAzSRUiE0RFWmUUmsDkMrts+KiLXb6STkOLBysQnLUHMUNQyK5PysuzYG33klg41oiLMpUNRKCsTxKz1QR9970QW7XsJAcqf3Fc91be2ZwKWgTOyBCwtuyxCI3QMNfibXL+uwUFS7Ldsf3LjK4kuiRlDa1ie/90H4BwAl7pXKzXtagC/F6zMcQaAl0S2+0EAPw7g/arVF+t5V994J4B3ztMGIYRMhDfGE6H/JYQsDPreidD3EkIWyvL876UA3i4i5wH4MoCfBAAR2QPgRar6QlU9KCIvB3CDq3OJqh50dq8C8FMADhORAwAuV9WLAbwewJtEZD+AgwDOjhkM0zcIIe1EGUJMCCFLh76XEEKaYYn+V1XvAHC6UX4jgBcGn68AcIVh95sAftMoPwTgJ6YdDyclCCHthTfGC8NKt8ilzJXkneXqRn5JWcR/UHdYEv8Zpi540cbKnizxRjOlY8w+7aSk3fLmSu1iy4x2rBQMuyws1Ny2XJ2KlI6s3zB9w6en9YyBhtGYxnafomEJXZril+GgXdqGWkKXk8ZQhpG+kb3vFctMUUuzLEjVyEQyrfaMdAsr9SNsr1cso9AlIVuHxLiOWqnp89gBcXaDxLdbFH4chHncht1oU2Saby61oleoOyjJQ7e2DULNTTcuu43yNH0/lip5AMvOOqZ+n2Kz9KPpqP/lpAQhpLXwaR0hhCwf+l5CCGmGrvpfTkoQQtpLRx3zIhEAfUmwWaFw2/fREyhGVFjfixU9USUanGkAhk9usvfGk3creiJSXDJWhNKMYghXuSyLOkCF3fg2lEcsVIlaxgpdmst6+oOvxs6FZf3iQci+hvBJPyZTJXSZLUE6LH6/+fH5JUFncAxWpIclftk3ykyhS3f+BYKY2bKevWJ7WtFH2flXFRWRRVTECq7GQN9LyNzECvbPY2cvl5nahU/3Y5fVHEUJDIOyZsUgrbFXRTFYS33Od5yLx3RhdNT/LuHIEkLIbIjG/0W1J3KmiHxWRPaLyIUTbH5SRG4SkU+JyF/UuT+EELIVmMb3dvWpHiGELIKu+l5GShBC2omi1tliEekDeA2AZwE4AOAGEdmnqjcFNqcgXero+1X1ThF5RH0jIISQLUDNvpcQQkgkHfa/nJQghLSXeh3zqQD2q+rNACAibwVwFoCbAptfBPAaVb0TAFT1tlpH0FJGQpdhqHy1ffrehTlWhDT6OlUpHWLY+fdakdKByJQOzfooGqoRPg+rKFZI0mi7SoRyFMo/Ksz20xSmNDrpFdMtzH0LUg0kE7W02guKjK/QyHQxsYQukbj0kuC71CTJbcu10ZvdMeSEM/0+GeKXoQilJVZpiVqOUjqMsvD4Gd+baefbFsOuIt1nbjp6U0zIojEFJI2LVqxdmb0l/GjZrWBYKLPq9ALnPxJ5jHMW+VTQpDAWv2/xKSohxfasuqM+pju2k4jd96npqP9l+gYhpJUIag9hOx7ALcHnA64s5FsBfKuI/LOIXC8iZ9ayM4QQskWY1vdutxBiQghpigXc+24ZGomUEChWpXxWDgBWIwVJVnrVbQHAai+uvX4/zk76kWdDpF0S+W30Iu0qdOxG/a7Wazdci5tt7O2Ms5Mkdu4sboD9flx7shl3XsU6hWQlrl+NtBvuivuChzvj2hvsiFzqKfI8qIXpHO5uEbkx+LxXVfdO2eMKgFMAnAbgBADXiciTVPWuKdtpNT0o+oF/tUQv/ROA2KiI0M4/8c4v/1nEioqwwhxGYpBhVIR/L8UyS0Aw12BxmxYfSpe3J7PYzV6WHXItt7OEM7NDmhN71NzQgeCaEX4HPeM4l1DsYZJhr/A2i44AAOm7beEAJ0fM2OEbJeKWCKImesZ2Q5gyH2VRImppLetpRE/kvqP+2DbYy4Ra0TGaRXKgPrbZzS4hbSH2iXzZU/2qdqd96p8XxLSWGDUiOWpwEtMei2XXrWybS4LWCtM3CCGtRax/NCZzu6ruKdl+K4ATg88nuLKQAwA+pKqbAL4oIp9DOklxwzQDIYSQrcyUvpcQQkhNdNX/Mn2DENJOdMq/am4AcIqInCwiawDOBrBvzOZdSKMkICK7kaZz3DzXfhBCyFZiWt/bzftnQgipnw77XkZKEEJaS535cqo6EJELAFwNoA/gClX9lIhcAuBGVd3ntp0hIjchzTj4H6p6R32jaCd9JxLVD0SxBiimdPR9WkZOsMqrKBbbzad+TE7pyIlaZmXF9qzsCDMKM5fmMfYaVpojBcMSGowXsIyrmy8rikHCSOkYpXkUUzByv6cs5N9IncmlHFoSltOlcuROjSw9opiWYaZ0qGEXEpdtaYtajo8JQcpEmOZnplFEiloaKR1+LJVpGd7OSuMxymqKSE6b32Y3u4Q0gU+LsFIiLLsQXyeflmE9S7bSLWLtrNQGXzfWuU7P6LgMgzIZ6z9XI6q9WLvY7yO082VJ5PVvHrrqfzkpQQhpLzU7ZlW9CsBVY2UvC94rgP/m/gghpJt09KaYEEIap6P+l5MShJDW0tXZ4kUiTuSyV5GzOFqyK3iiUCJwaUVPDMOABS9qadQdBqW+LDGEM8PaI5HM4lPuHKXRDmEfhvigVTezt9oztpeNKawbPpjXuLLskFeUmXXH7XN1LLnKqrISwoPlTwozcsWKiggMEyPiIzIJ1Tw3suU1regYQ5jSWsIzZ+deLVFLq26/WGYu/2kuJ1oS0VPDgzz6XkLmp+qJ/LR20/ZrRR3UJfJYB20aS0jd38e0dNX/clKCENJeOuqYCSGkUeh7CSGkGTrqfzkpQQhpJ9rd2WJCCGkM+l5CCGmGDvtfTkoQQtpLRx3zMugH4YmWCKU/9v2gzKdoWHa9XHu9nH1Iz0jLCCPRk7Ft4fuwTFEM+Rcr9H7aNAozBUONQqMdy84SKUyKZla/dlm5gKXvI19mSE5maR5WWkZImdBlufhllpWRFM1yWUFJfluucphm5NMZZvEL5vfvUzCKZbl0C/O7NIQurdQKQ9TSp23kyqLFL4tjHtV1r6gB+l5CFkp4LbTSGHrmf6bFtALLzrdnpSFU97v41IVRemhxLFVjHref1F6ZndV2VSrJKCWmKAJeOx31v5yUIIS0EkF3Z4sJIaQp6HsJIaQZuux/G5mUEFHs6G1W2sXYAMBab1htBGC1X69dvx83mzhciZx1XIlT7AqfzJSRrMZ1m6xF2g3i+h0O435NksQK3NR8XNbi2pNB3GxorPOIHt9K5HHeEbcfwx2x7cXaRZnVgiQd9cyLRNyMfzDb3zeeMpQv9VmMishvL0Y2jEQty+2y98FTi+xBde6Jto8SsKIiKpYElcKb6GiH7Om1FSRgCU5akRehmRnZEFcWK5I5aqQYZZHHioAY3xZuL5aFkRxiHZchina94neeHWDrOjFTqMT4oGBeWkqjIsKhZCKUxWgHO6LCKLMiIIwlQc3lPw3xyzpXqqvb94rImQD+BOlyzJer6qVj288F8GoAt7qiy1T1crftHAC/7cp/V1XfUOvgCGmAqifzo8iB8t9irF1TtF10M3YM9lKli6Gr976MlCCEtBNFZ0PYCCGkMWr2vSLSB/AaAM8CcADADSKyT1VvGjN9m6peMFb3GAAXAdjjRvVhV/fO+kZICCEtocP3vsub9iGEkCmRJP6PEEJIPUzjeyP876kA9qvqzaq6AeCtAM6KHMqzAVyjqgfdRMQ1AM6cdb8IIaTtdPXel5EShJD20tHZ4kUiAPpQU4QypO8EtUI7K6WjXPyyWDcsGxphp5moZThmM83DEroshtlbopFWloJmfVSIZJqpJJZddhCCTtxL+DjA31RYqR9VZVYuiZm2UVI3OlWjoq47IGHYaZYKEYpaFr+2UU5P7hRy7fWK59VceQpWNkj4ZVrniykuOTnNI1cWKWpppmVEil9ivG4dEdH1+t7jAdwSfD4A4KmG3Y+JyA8C+ByAX1fVWybUPb7W0RHSMD41wBJitNILwlSCUXrE7HaLZNq0B9u+/L/vxFKRLrGrEvOMtzNSPOugo/e+c0VKiMirReQzIvJxEXmniBxV07gIIQSi8X9dg/6XELIopvG9zv/uFpEbg7/zp+zyrwGcpKrfgTQaorW6EfS9hJBF0tV733kjJa4B8BJVHYjIKwG8BMCL5x8WIaTzKOYTtNv+zOV/c0uCuuPcD54yDFB8UuDf9wNxy8SIgDCXAoUR7eBfcxEV/jV44m7Y+feaU5L0fYyKRtEOs4haarGuIcpYFlExU5SFP7xaLMvpXGaRF8XIBksk02aGqIhsU/HY58MExrdhJFyZi1IpmiEpfr+lN2BVAR9WlUyI0/ou477fuZb1NKMi4uyqxC/nYjbfe7uq7pmw7VYAJwafT8BI0DLtUvWO4OPlAF4V1D1trO610w6uZnjvS2oldhnOZYgtxkYJeKrsyoQuiUGH733nOkNU9T2qOnAfr0d6sSCEkFro6mxxDPS/hJBFMUOkRBk3ADhFRE4WkTUAZwPYl+tP5Ljg43MBfNq9vxrAGSJytIgcDeAMV9YY9L2EkEXS1XvfOjUlfgHA22psjxDSdbaZw10g9L+EkPqo0fe6iIILkE4m9AFcoaqfEpFLANyoqvsA/IqIPBfAAMBBAOe6ugdF5OVIJzYA4BJVPVjf6OaGvpcQUi8dvfetnJQQkfcCeKSx6aWq+m5n81KkF5I3l7RzPoDzAeDo43bONFhCSHcQbL9Z4GlZlP/tSTJS4MMolcMUpgyujn2jbNw+fe/bq0jzcO+HQSqEJWrp4+dz2QI+5D8QQpRhUZDQTtUYayQo07A9Q8TKCuUXK7w/S8EI+vVh/Ubqgpn6YQhdihG2n8tS0Py2cHv1zylS/NK/za2lboiM+u2JUVeLByEskuxYFdN4cqOK9BGmtpsUC0tTNcKUjn7RTk1BzGJfsaKW5XbFMefTeGZnEb5XVa8CcNVY2cuC9y9BmgZh1b0CwBX1jqicRfjeXccesYCRku1OTkS6RMgxtEsyEel6UjAsu0WlY8SOpaqOPx6hsGfdx2MRdPnet3JSQlWfWbZdRM4F8BwAp6tOToJR1b0A9gLAiU98SEcPNyEkGtXO5tV56H8JIUuHvnchvveoxz2i2weVEFJNh/3vXOkbInImgN8E8DRVfSC2Xg+KnbJZaberX20zjd2O/qDaCMDayrDaCMBKpN1gtV9tBCBZiRS6WYt7GiJxw0MyiGtvuCOuPfuR1OzEPv1JVuJ+xL1BnJ0Ma54FjjwsyUrk97Ea194w8nyJ/X6HO5e3nFRXZ4tjmNX/CtySoDmhy/Rcz4lfRi7/mUVF5J5GFO0K7U6wUyNSwhLEHEVUwCgzBBiNJ9WV4ohl0RO5pSpLIjQqlvWU8W3B+KLFKnOCmJOjHaokLUstw6KkaJd9b+FlzC/RGu6vFT1hDcbflFnXEzXflmNGShhNG4KnpriksW/WcqKWWOV84peT65qiqTNC3zuZWX0vIbMQu4Tnspf6bDtb+Xh01f/OqylxGYAdAK5xN4HXq+qL5h4VIYQAnc2ri4T+lxCyGOh7y6DvJYQsjo7637kmJVT1sXUNhBBCxunqbHEM9L+EkEVB3zsZ+l5CyCLpqv+tc/UNQgipD8WYkB6pi54k6Ac5iz4BLidq6WL0+4GwViJF8ay+E7MMk+MskUxfFqZfZ+kWQV3JUjpGZf1e2p8mvYKdnaoRKiaKUTb2mg42JUgr8GkbomGZfxPWLdrBsDPbM9I8fOpdlVhllmFjpnaUJ2tEi1/642f8FvOilsW0h6xObtBGSocW7dQ1ZOqNzeMWrJQNMwXDEEE1xS/DMiMFoyRVw0oRiU/fKJ5rtenO0fcSsi0IxSjLxBtj7UKaFIMcx49/GWNaeFpIh/3vYqRTCSGkDnSKvwhE5EwR+ayI7BeRC0vsfkxEVET2zLcDhBCyBZnG93bz/pkQQhZDR30vIyUIIa2lzhA2EekDeA2AZwE4AOAGEdmnqjeN2R0J4FcBfKi+3tuDQNFHMhbtkL5Pgke3plilevsgAsISv8zKQuHMdA48MYQuV3ojOx8NkRe19GNHsSxn5yM5RmU+uiNamBJGWc6uKJxpCRfCCw3nIgK8XSji6SsHw8uiNoL2SsQvqwUspxS/rBS1dCXh0xwZtx9FG+TGrGqUFe3MpU1rUCRXYxlQW/CyuD02KsKMgKhYEtQWv7TK/Pk82a4Ot9nV8GFCtgKzRDY0Tew4F7lvy4yomIeu+l9GShBC2otfGinmr5pTAexX1ZtVdQPAWwGcZdi9HMArARyqb0cIIWQLMY3v7ejydYQQshA66ns5KUEIaS2i8X8RHA/gluDzAVc26k/kuwCcqKp/W9tOEELIFmMa39vVp3qEELIIuup7mb5BCGkn0+fL7RaRG4PPe1V1b2xlEekB+EMA507V6xakJ5oTusxCGbWflfmUjlxahk/pUKMsTNXQYhqFlQ7i34cpHTK2DRiFvufKvPhlEOrpUzm0Mt3ClYXT8r7psCzxIfrB+LQYto+si+CE9WH2YTqD9RjA6NdMtkiKdhblApYViR5GCkZmnRO19G+CwqR47LPDEbaXKT8afYQiqOb2mgXGytI2wnQLKy2jpCwnQmmlZVjpPr38tnB7lahlIc1j3sM0ve8lhCyRusUo25TOMMtYtuJ+TmSJ/ldEjgHwNgAnAfgSgJ9U1TsNu3MA/Lb7+Luq+gZX/goAPwfgaFU9IrA/F8CrAdzqii5T1curxsNJCUJIKxFMnUN+u6qWCVPeCuDE4PMJGDlMADgSwBMBXOu0CR4JYJ+IPFdVw8kOQgjZtszgewkhhNTAkv3vhQDep6qXOvH3CwG8ODeedOLiIgB7kE6XfNjpsd0J4K8BXAbg80bbb1PVC6YZTCOTEj0oDuutV9od1tuIam9Xf7PaCMDOWLuVQbURgEMrw2ojAJuRdslaXDZNMox7DCLDuPaGsROHtT+limsv6cf9OIerce31BpHHL/K4xDqP3NOuEpJ+tQ0AaOSvd7gW2e9aXHuDnXF2tVDvpPYNAE4RkZORTkacDeCn/EZVvRvAbv9ZRK4F8BvbdUIiJ3TpzuHcEp7ufbgkqH+fBL9d345fGjTdXoyKWHHrXObqWiKZ7n0/EL/0S3DlRC2zsmCfXERD+ER9FI0RGrp2qpb6tKIsMrtiVETOE/gP4UPzkmVCrcfbuWgB6+l6CbHil/kIiBJfZm0K98OLWuaiIiZHT4SHb7Sfwfeh49sqsPxwxTXGvKRFL//py8qXDrWiF8rK8hEV1aKWk8rmZgs8UCSEkG3J8vzvWQBOc+/fAOBajE1KAHg2gGtU9SAAiMg1AM4E8BZVvd6V1TIYakoQQlqLqEb/VaGqAwAXALgawKcBvF1VPyUil4jIcxe8K4QQsmWYxvcyqoIQQupjib73WFX9mnv/dQDHGjaVemwT+DER+biIvENETqw2Z/oGIaStLCCvTlWvAnDVWNnLJtieVm/vhBCyBaCmBCGENEPNemoi8l6k6cjjvDTXraqK1Cad+ddIIynWReQ/I43CeEZVJU5KEEJayvZb7qgNCNI0jARhioNPwQhSJlAiVhlcMfuubCWoO8yEKXvFumEKhtFelm5hpGD0A8FJL4qoQZqHF72UnEim7yzMFxCjzHc2Ksoq58QM0zoSpGOpG7+Ecfs+lSSs7DP5TFHLCjFNv61KONPAFL/0uxa2Z1ladpYgppGF4tNowsM8SstQo6w49ioXYKV+WJRmH1oClsb2mVI1jPPKFLo0RDKj0zz8+7qELul7F0qioV9kngwhJGRq/1uqp6aqz5y0TUS+ISLHqerXROQ4ALcZZrdilOIBpHps15YNSFXvCD5eDuBVZfYepm8QQlpLV5dFIoSQJuGSoIQQ0gxL9L37AJzj3p8D4N2GzdUAzhCRo0XkaABnuLLJ408nODzPRZoyXQkjJQgh7YVP6xaAoi8JhsGcdCZ0mVvWM90eRk9kEQsalKFY14teWhEQYdmKX9YzEO/1ApdhpISPfMgJXfqynJ3rKxdRUYz4yEQvAzv/+Dr3pDwTxAzLvKhlZGSDJYgZPhztebtgKK5fCYUfi01n0QvRAofhvhkPaLM4iaqlPpOxCsEAcwKWSX5bzi6obIlfjrZZ4RPm23JKogfUEumKXP6zsqwkesJc6tOqG7ucaJ2Pmeh7l4KPmmDEBCEkY3n+91IAbxeR8wB8GcBPAoCI7AHwIlV9oaoeFJGXIxWLB4BLAtHLVyEVjD9MRA4AuFxVLwbwK06rbQDgIIBzYwbDSQlCSDvR+BVQCCGE1AR9LyGENMMS/a9LszjdKL8RwAuDz1cAuMKw+00Av2mUvwTAS6YdDyclCCHthU/rCCFk+dD3EkJIM3TU/3JSghDSXrrplxeKAOghQR9hWoYTutQwxSEt6wVlqzJ02wyRzFA4031xK71hVpYkkrNP7ZwQYiimmaWDFMU0NSzzQpKhYKJPBwmF5JzdMKdz6dsrClPmMhJ8rHwYFu93KZfmkdUIKlspHcW0DJSmYAQpIpCxkhGV4peWMKXVmyFqmeXE5Mr8sS+OQYqHIG/n3xspGLn82JI0j3koE7KcaGeIWiI2fcNK1ShJ87DFL4t2Zt16lop3jdXYFpkI0zYIIQU66n85KUEIaS01rMFMCCFkSuh7CSGkGbrqfxuZlOiJ4vDeRqXdkf1DUe0dvrIeZXfk6lqU3QODOLtDa3GHb3PYj7JLkjiVquEw7nGIfzJZSd3nviUaZnUbd1jQW4lrrzeIa09i7WKdQuzjqdivox/5/Ub+epPVeu2GO+LsaqGjjnmhSBp5kASPvr1wpY+EAIChO2GrlgnNoidyy9w5QcxQ6DKLngjaG/YKZV70sh/a+aUlreVEc+31XVkodOntRocgcWViuNzcKee3W2WBf82EKdUos8Qqw/Z8dEL4NLw4rKx0JvFLzXWVr2sIWOZcmiVq6fc9tx9G9IQRFYGSMqO5HLW7g7IIiYqIinihS2tZWb+t2HZspIQVEVNrxAR9LyGENENH/S8jJQgh7URRGW5OCCGkZuh7CSGkGTrsfzkpQQhpJQLtbAgbIYQ0BX0vIYQ0Q5f9LyclCCHtpaOOeZEIFKsywDCI8fbpFr1cSocvK6ZghCKZXvQyFGxbdQKXydDqI2jPi2mGYoamnes3iOlXQ6zS2+WyLTJBzKAPn1oRpsL5t0HqR5lYZY7E21nClEFZJpwZ7IfvOHgy4lM5ytI48n0EWKKW/r2RGmA+kTHSS/JCl4adldLhf7+RopZi2C1U8KtK4HLMzha/rBCwLEnLqBSrNMrKhC5jUwSjoO9dCj7tjYKXhJCMjvpfTkoQQtpLRx0zIYQ0Cn0vIYQ0Q0f9LyclCCHtpMN5dYtEkApQhlEHXugyQRh14MQvAwXZ0bKe5Ut4+mVEc4KYRvSEF7j0gpdhmQZ2XvQy0fKyTPQyEA1WQxDTLxkqQZmvE71MaO6pudvPYNlHHyGRF79EAYGP7iguExorfpkTF/Z1i1a24GR+MLk2cnaW+KUVUZHrw4qeMKpqUSRztM0YZ03ELw9qfedGG1MuHRotdGn1YS0TWlfExAJ8r4icCeBPAPQBXK6ql45t/28AXghgAOCbAH5BVb/stg0BfMKZfkVVn1vv6AghZHqSWtdhdnT43neuSQkReTmAs5AevtsAnKuqX61jYIQQ0tW8uhjofwkhi6JO3ysifQCvAfAsAAcA3CAi+1T1psDsowD2qOoDIvJLAF4F4Plu24Oq+uTaBlQD9L+EkEXR1XvfuDUoJ/NqVf0Od7H4GwAvm39IhBDiUI3/6x70v4SQxTCN7632v6cC2K+qN6vqBoC3Iv2HPuhOP6CqD7iP1wM4ofZ9qhf6X0LIYujove9ckRKqek/w8XAsVpKKENIptp/DrZNZ/a9A0ZckS9kAgFVJUzSGwTy1F7pMDKHLVRlmZT58MVfmwt19ygYwSttYCcuSyWX9ILXCLBv2C2WqaZmGqSSWIGaveKgSt79iTNXnTkNzKt+LVQaGvj9DJFON+HoJjnO0+GWWbmHlUVh2QZF7n0sXsFI1fFmV0KUWy/xxqxa1NNI8xtqYROwTpVxaTqGR8rJpxS9rE7q0+igTxDTO69mo3fceD+CW4PMBAE8tsT8PwN8Fn3eKyI1IUzsuVdV31Tm4WeD9LyGkt5D8wu7e+86tKSEirwDwcwDuBvD0uUdECCFAeovXUcccC/0vIaR2ZvO9u93EgWevqu6dthER+RkAewA8LSh+tKreKiKPAfB+EfmEqn5h2rbrhv6XEFI7Hb73rZyUEJH3AniksemlqvpuVX0pgJeKyEsAXADgogntnA/gfAB4xKNWcGTvwcrBHdnfWWmT2u2Ksru/vyPK7ojV9Si7zaQfZTcYxtn5p4FVrEfaxQqwJLFZPJF6LpaYm0VvI67BXuTUWfCgtry9SDtEHudoaj5+GndaIYk8fslanBNMVuPaq4WOiv14FuF/H/6oVfSQ5Jag6zsfYEdPjE5cL3oZ+ip7qU9XpsWyvhF5ET5tWHE/5CR4st13Yw3LMkHMQNRyFDURCF16EcVQ1NJtt5YJzWlfZtEOxd+G+WsJfW72hFyDomKIQVnUhCV+CSOyIR/YUCwUv2RpvpN8u6GBFQFRFT1h1PVfa65fX2bYwbCzMKMsKii9HE65NGj4vjahSxhlZREVOTstls3L9L73dlXdM2HbrQBODD6f4MpyiMgzAbwUwNNUNbsRU9Vb3evNInItgKcAWPikRB3+N/S9u449YpHDJYRsFzp671v574qqPjOyrTcDuAoTbordjPleAPjWJ+3q5hQQIWQqJOmoZ3Yswv8+9kmH0f8SQkqp2ffeAOAUETkZ6WTE2QB+KtefyFMAvA7Amap6W1B+NIAHVHVdRHYD+H6kIpgLpw7/G/reox73CPpeQkglXb33nWteXUROCT6eBeAz8w2HEEIcijRXPvYvAhE5U0Q+KyL7ReRCY/t/E5GbROTjIvI+EXl03btVF/S/hJCFMK3vrfC/qjpAGklwNYBPA3i7qn5KRC4REb+856sBHAHg/4nIx0Rknyt/PIAbReTfAHwAqabETWgY+l9CyEJYwL3vVmFeTYlLReTbkAaafBnAi+YfEiGEAHWL/dSwLF3bmMn/eqHLNYRilS59I0jpGGYpHaPvwItehqkaXuAyTBdbNVIwvOilF7wERgKXVjrISjAW345V1g9j+V3uRTiWns/HCNI8vBBmz0jpGOa0KtUPKrArSeWwTtdg33wqhxi5EJXil26zhO0ZKR1ZgoiVMxGKPSZjFcKyCgHL0pSOMLXCELU0j9GUZXN5hapsj7JUDkv8cpaUDqOvLPXC6qNXLMuJWo6LX86deVi/0JqqXoU0miAse1nw3oxKUNV/AfCkWgdTD7z/JYQsAApdzoSq/lhdAyGEkAL1OuZsWToAEBG/LF02KaGqHwjsrwfwM3UOoE7ofwkhC6OjN8Wx0P8SQhZGR/3v3KtvEELIwmjXsnTbhj4Uw0BJyYtergbRE0P36NYLXgIj0UsveAmMohzC5T+Hia9bjMYwlwQ1IiBCIc4VF6kQRkCs9Io5l9YyoSNRy6LoZu4JtProiaA9FKMsRlETYUiAE5I0lv/MD9DbRYpfWlEMKNbVcHf74/ZBO7klS91LGHmRlQV7URYpocUiMyqiIlLCjKiwqPs+bVqByyr7OqIiTDs1yop2WRSF0f3UdPSmmBBCYoldUGBqOup/OSlBCGknPq8unlqWpAMmLktHCCHbn+l9LyGEkDrosP/lpAQhpKXo2CPgSsqWpAPmXJaOEEK6wdS+lxBCSC101/9yUoIQ0l7qDWGbeVm67YRAsSqDLBUDQCZ6mQT5B170chjkOHjRyyQIEPeil6b4pYTpFkVRS5+2MQzt/PswjWLoUz9GF2od+jSPUb8rJaKW/VAY0OU2aGDX600+15IwF8LV0VA0MhOwHKFGWsaojQrxSzfm8L4kS9XINVQiYNkzzMIiLxoZHL8slaNCwNISxPTN5MZnpBOI1d54X1VldVESeWulZUzcPmZn1p0lVaNE6DJXhrGyOiKKOxo+TAghsfQqcw5npKP+l5MShJB2UnMIm6oORMQvS9cHcIVflg7Ajaq6D/ll6QDgK6r63ImNEkLIdqPD4cOEENIoHfa/jUxK9CXBUf0HKu3uTXZFtffQ/oNRdodWV6Ps1pO4w7IxjLPbXOtXGwEYJnGPNzRSWGUjygpIJHJ8vV61EQDtx9pFmSFZi7ML9PhK6Q0jHyMtQVTN7LbkiW3OLvb4Rdrpaly/ydoSnWVLlqXbTghSoct+cIJ70ctQXNKLXg6D6AkvehlGWXjRyzACIvGCmDmhSy9qGQhiircLow5QaM+KssjELMMghkwkU4t2AaMlUIvLieZDDIok7pwUwywXEZCVlS8nmolf9oNtiW8jiKhAMaJiJExZFMkMdy2LuAh9ge8jp9fpIjTCCIjEaM8KAikRtaysO7moWvyyBqK1yiKXBM21XSpqaURF1CSIOTcdfVJHCCGN01H/y0gJQkh76ahjJoSQRqHvJYSQZuio/+WkBCGkpWhnHTMhhDQHfS8hhDRDd/0vJyUIIe1EASTdVCBeKJKmaaxilO/k0zG84CUwSnFYldDOlZl2QVqGK7NEKIdJmA6SliVBLoRPK1kJUkl8WkaY+pGleWiY5mGcL66/JJfS4d8XBSyRa8OJWgZ9iKvbM6qG+B4qxS99Ua5bL2oZiFB6ocswRN9K+fPbw/Z8ekxx1/LEpnRkqRphDsHY66Sy8W0TtmfCmVWpFWX3brEpcyWilZPKSuvUlKpRJpyZS/PLykrGPg30vYQQ0gwd9r+clCCEtJeOzhYTQkij0PcSQkgzdNT/clKCENJeOuqYF4lAsYYhkuBReSZqGZZJsWzNRVeE0Qkju2JZiK+TE7/0Qpe9wN49IJhlmVBrOUwf5VAtajl5OdGeET2RKylWHbURvM/iJMIn2cn4VoyUt3uhqKUTusxFR2ihPb89X1ZiFw4wNnpCx99gQjSEsSZoHUuBzuIW6oiaqFoaVIrHOXZJUGv5VP995NrrGX1YdvNC30sIIaUktTrdgI76X05KEEJainZ2WSRCCGkO+l5CCGmG7vpfTkoQQtqJAqrdzKsjhJDGoO8lhJBm6LD/5aQEIaS9dHS2eJEIUqHLXpCA0Hex4/2gLHHvc4KYRgqGKX4pPsUhSOlwKRp5octimodP21gN0jcyUcsgdWHFp3wY4o06HNn1S8QvbVHL0TmXCXXm0hqKqR9ZSYX45UiEMkjLMMxGsfxFUUtL4DBM6VCjD1NMM1OSDIpiUzpiRS1dQ7kUFkskc3wbJhyXOtxBRbStnb5R7Lg0BSNWJLNS1NIdv17RLi+SqcX25oW+lxBCSukZ14Za6Kj/5aQEIaS9dDSvjhBCGoW+lxBCmqGj/reRSYk+FEf1NirtHujfF9XeIV2NtIvb3fUkzm6g1iOkIkmtjy/ikcgZvI1enN2w34+yS/px7elq3PHDIO749QbVNgAwjIyKip4AjbWLFVqL/D407uuArkS2F2mH1SWFlal2dlmkRdN3YpeexIh28BEQ/VDo0kU2WCKZiVZEQBhLh/pmrGVCc6KWiV8SNDgfDPfh7foV4pejbUGhq6OWCmXObrzhUaElfhleJkZtG0/eww9WZINlqMVlQrOoiXAJSt9OGH3iy6wwBqOPeZb6NCMgjJuuqvuwuh9KlWqUWWKVVt2qqIiS9mqLihhfJnTeA0XfuzCSCfeNk8pJ8/Sk+Fuwvq8yO2sbaS/W92b9L+eFLmv9/XbY/zJSghDSXjo6W0wIIY1C30sIIc3QUf/LqVlCSGvRJIn+I4QQUg/T+F76X0IIqY9l+V4ROUZErhGRz7vXoyfYneNsPi8i57iyw0Tkb0XkMyLyKRG5NLDfISJvE5H9IvIhETkpZjyMlCCEtBTt7GzxIhEoViXBMBShdGKWYVmY3uHx23NpHllaRjF/KteHkdKRGMKZpqilkdKRZVZIaDcs2o3ZT9quLkWjb4hf5ipnIpnFxiUYix9XuB+jumEYqBGO71M/wkJLwDITwwqELnvFFIxsXIF41iiTxMg1CHZXvFilkdJhp2XAKDSoSv3I+o9rbhai0zeMMnMsVrpFVlYUKFUjBcOsa4ibLlbokr53USSQzO8BCxTK6zA99+u0wu17M3iR2ND8MrtlpOd0LUWkKoWmjmNutZGUXjjqYKn+90IA71PVS0XkQvf5xaGBiBwD4CIAe9LB4cMisg/AOoD/qaofEJE1AO8TkR9S1b8DcB6AO1X1sSJyNoBXAnh+1WAYKUEIaSeK9J+o2D9CCCHzM63vpf8lhJB6WO6971kA3uDevwHAjxo2zwZwjaoeVNU7AVwD4ExVfUBVPwAAqroB4CMATjDafQeA0yV8ajMBRkoQQtpLR9dqXiQCL3QZCjgVRSh9BEQ/uI6smaKWVoREUTjTioBYNZb19E8hVozoidDOLx26YiwdWhUVYUVZ9LPlP61zzgrRGJWJE/dNzHVAw5qGcGY/25iRxT/kxCqN67kliGksuZktc5oLvDCiJ0YdG+2FfViCmMV+C9vC90awSEOa0OVRDxVlllilGe1gtJMXtZwsYBkdFVFnxAR971Lw/o4RE/VRJi4fKzw/S0QFaZ5tIxi7PP97rKp+zb3/OoBjDZvjAdwSfD7gyjJE5CgAPwLgT8brqOpARO4G8DAAt5cNhpMShJBWogCUT+AIIWSp0PcSQkgzzOB/d4vIjcHnvaq6138QkfcCeKRR76W5flVVYpdtDBCRFQBvAfC/VPXmaeuHcFKCENJOVPm0jhBClg19LyGENMP0/vd2Vd0zuTl95qRtIvINETlOVb8mIscBuM0wuxXAacHnEwBcG3zeC+DzqvrHY3VOBHDATVo8FMAdFfvBSQlCSHvh07r6EcAQukxTJYZBrPmaT58IvoKhlebhypIgh2DVSPNIXEOW4OVQRnYrPn3CuCYPg7SCVf/eyKyoKstSRKxUjTC1oiSVQ4L9yNI2TJHMIhqIcfm0jLBbv2vmfUkYyu9TOsKHG74sFMqaNqUjqJu9NYQu7fSNUaEfVu5XbApcFkOqzbplWIaRaQyVumXWw6MyscpKuxpSNcIx9YyyOaHvXQwrMszS5UK6JlJIyLws/Tfj7mesVKu6x7JE/7sPwDkALnWv7zZsrgbwe8HKHGcAeAkAiMjvIp1weOGEdj8I4McBvF+1Wr2TkxKEkPbCp3WEELJ86HsJIaQZlud/LwXwdhE5D8CXAfwkAIjIHgAvUtUXqupBEXk5gBtcnUtc2QlIU0A+A+AjTsfyMlW9HMDrAbxJRPYDOAjg7JjBSMTERe2IyDeR7vyy2Y0KkY1t3D/3vTm62v+jVfXhs1YWkb9HOvZYblfVM2ftryt01P929TfYdN9d778rvheg/62ko7636f67vO9N99/Vfee974w0MinRFCJyY1nezXbun/vezX1vQ/+EAPQB3Pfu9d/0vhMCNH8edvk32OX+u7zvZDa2ydophBBCCCGEEEII2WpwUoIQQgghhBBCCCGN0LVJib3VJtu2f+47+yekSegDutd31/tvet8JAZo/D7v8G+xy/13edzIDndKUIIQQQgghhBBCSHvoWqQEIYQQQgghhBBCWkLnJiVE5OUi8nER+ZiIvEdEHrXk/l8tIp9xY3iniBy1xL5/QkQ+JSKJW4N2GX2eKSKfFZH9InLhMvoM+r5CRG4TkU8us9+g/xNF5AMicpM77r+6xL53isi/isi/ub5/Z1l9EzKJJv1vk77X9U//u7y+G/O9rn/6X9IqeO+7XN/r+qX/5b0vmYLOpW+IyENU9R73/lcAPEFVX7TE/s8A8H5VHYjIKwFAVV+8pL4fDyAB8DoAv6GqNy64vz6AzwF4FoADAG4A8AJVvWmR/Qb9/yCA+wC8UVWfuIw+x/o/DsBxqvoRETkSwIcB/Ogy9l9EBMDhqnqfiKwC+CcAv6qq1y+6b0Im0aT/bdL3uv7pf5dEk77X9U//S1oF732X53tdn/S/vPclU9K5SAnvlB2HA1jqrIyqvkdVB+7j9QBOWGLfn1bVzy6rPwCnAtivqjer6gaAtwI4a1mdq+p1AA4uqz+j/6+p6kfc+3sBfBrA8UvqW1X1Pvdx1f11awaStI4m/W+Tvtf1T/+7vL4b872uT/pf0ip477tU3wvQ//Lel0xN5yYlAEBEXiEitwD4aQAva3AovwDg7xrsf9EcD+CW4PMBLPHGsE2IyEkAngLgQ0vssy8iHwNwG4BrVHVpfRMyiZb43+3uewH6XwDN+F7XL/0vaRUt8b0A/W9n4L0vmYZtOSkhIu8VkU8af2cBgKq+VFVPBPBmABcsu39n81IAAzeGpfZNlouIHAHgLwH82tjTioWiqkNVfTLSJxKnisjSU1hI92jS/zbpe2P7J8ujKd8L0P+S5cN7X/reNsF7XzItK00PYBGo6jMjTd8M4CoAFy2zfxE5F8BzAJyuNYt6TLHvy+BWACcGn09wZZ3B5bT9JYA3q+pfNTEGVb1LRD4A4EwAjYh+ku7QpP9t0vfG9L9kOu1/2+B7Afpfsjx479sq6H9570umZFtGSpQhIqcEH88C8Jkl938mgN8E8FxVfWCZfTfADQBOEZGTRWQNwNkA9jU8pqXhBHdeD+DTqvqHS+774eLUrUVkF1KxpaWe64SM06T/7ZjvBTrsf5v0va5/+l/SKnjvu3Tof3nvS6aki6tv/CWAb0OqxPtlAC9S1aXNXorIfgA7ANzhiq5fovr88wD8bwAPB3AXgI+p6rMX3OcPA/hjAH0AV6jqKxbZ31jfbwFwGoDdAL4B4CJVff0S+/8BAP8I4BNIzzcA+C1VvWoJfX8HgDcgPe49AG9X1UsW3S8hZTTpf5v0va5/+t8l+d8mfa/rn/6XtAre+y7X97p+6X9570umoHOTEoQQQgghhBBCCGkHnUvfIIQQQgghhBBCSDvgpAQhhBBCCCGEEEIagZMShBBCCCGEEEIIaQROShBCCCGEEEIIIaQROClBCCGEEEIIIYSQRuCkBCGEEEIIIYQQQhqBkxKEEEIIIYQQQghpBE5KEEIIIYQQQgghpBH+f9p/S3b4JnozAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1080x288 with 6 Axes>"
       ]
@@ -171,15 +238,16 @@
     }
    ],
    "source": [
+    "# Extract coordinate grids for pixelated potential\n",
+    "x_grid_lowres, y_grid_lowres = hybrid_lens_image.Grid.model_pixel_coordinates('lens')\n",
+    "\n",
     "# Extract the true perturbation potential on original and low-res grids\n",
     "psi_grid_true = true_lens_mass_model.potential(x_grid, y_grid, kwargs_true_lens_mass, k=1)\n",
     "psi_grid_true_lowres = true_lens_mass_model.potential(x_grid_lowres, y_grid_lowres, kwargs_true_lens_mass, k=1)\n",
     "\n",
     "# Set the hybrid lens mass model parameters\n",
     "kwargs_hybrid_lens_mass = [kwargs_true_lens_mass[0],\n",
-    "                           {'x_coords': x_coords_lowres, \n",
-    "                            'y_coords': y_coords_lowres, \n",
-    "                            'psi_grid': psi_grid_true_lowres}]  # Transpose so that image_model works properly\n",
+    "                           {'pixels': psi_grid_true_lowres}]  # Transpose so that image_model works properly\n",
     "\n",
     "# Test interpolating the low-res hybrid model to the original grid\n",
     "psi_grid_interp = hybrid_lens_mass_model.potential(x_grid, y_grid, kwargs_hybrid_lens_mass, k=1)\n",
@@ -197,69 +265,16 @@
     "fig.tight_layout()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### PSF\n",
-    "Ignore the PSF for now."
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': 0.3}\n",
-    "psf = PSF(**kwargs_psf)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Noise"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Noise\n",
-    "exp_time = None\n",
-    "sigma_bkd = 0.05\n",
-    "kwargs_noise = {'background_rms': sigma_bkd, 'exposure_time': exp_time}\n",
-    "noise = Noise(npix, npix, **kwargs_noise)\n",
-    "noise_hybrid = deepcopy(noise)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Image model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 21,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Warning: previous noise map will be replaced with new estimate from a model\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x288 with 4 Axes>"
       ]
@@ -272,29 +287,21 @@
    ],
    "source": [
     "# Generate a lensed image based on source and lens models\n",
-    "kwargs_numerics = {'supersampling_factor': 1, 'supersampling_convolution': False}\n",
-    "lens_image = LensImage(pixel_grid, psf,\n",
-    "                       noise_class=noise,\n",
-    "                         lens_model_class=true_lens_mass_model,\n",
-    "                         source_model_class=source_light_model,\n",
-    "                         lens_light_model_class=lens_light_model,\n",
-    "                         kwargs_numerics=kwargs_numerics)\n",
-    "\n",
-    "image = lens_image.model(kwargs_lens=kwargs_true_lens_mass,\n",
+    "image = true_lens_image.model(kwargs_lens=kwargs_true_lens_mass,\n",
     "                          kwargs_source=kwargs_source_light,\n",
     "                          kwargs_lens_light=kwargs_lens_light)\n",
     "\n",
     "\n",
     "# Observed noisy data\n",
-    "data = lens_image.simulation(kwargs_lens=kwargs_true_lens_mass,\n",
+    "data = true_lens_image.simulation(kwargs_lens=kwargs_true_lens_mass,\n",
     "                             kwargs_source=kwargs_source_light,\n",
     "                             kwargs_lens_light=kwargs_lens_light)\n",
     "\n",
     "# Plot\n",
     "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))\n",
-    "img1 = ax1.imshow(image, origin='lower', extent=extent)\n",
+    "img1 = ax1.imshow(image, origin='lower', extent=extent, cmap=plotter.cmap_flux, norm=plotter.norm_flux)\n",
     "ax1.set_title(\"Clean lensing image\", fontsize=FS)\n",
-    "img2 = ax2.imshow(data, origin='lower', extent=extent)\n",
+    "img2 = ax2.imshow(data, origin='lower', extent=extent, cmap=plotter.cmap_flux, norm=plotter.norm_flux)\n",
     "ax2.set_title(\"Noisy observation data\", fontsize=FS)\n",
     "for img, ax in zip((img1, img2), (ax1, ax2)):\n",
     "    fig.colorbar(img, ax=ax)\n",
@@ -303,12 +310,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x576 with 8 Axes>"
       ]
@@ -320,13 +327,6 @@
     }
    ],
    "source": [
-    "# Hybrid image model for fitting\n",
-    "hybrid_lens_image = LensImage(pixel_grid, psf, noise_class=noise_hybrid,\n",
-    "                                lens_model_class=hybrid_lens_mass_model,\n",
-    "                                source_model_class=source_light_model,\n",
-    "                                lens_light_model_class=lens_light_model,\n",
-    "                                kwargs_numerics=kwargs_numerics)\n",
-    "\n",
     "# Test the hybrid model with the true low-res perturbation grid\n",
     "hybrid_image = hybrid_lens_image.model(kwargs_lens=kwargs_hybrid_lens_mass,\n",
     "                                        kwargs_source=kwargs_source_light,\n",
@@ -376,19 +376,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "truths: 625 dpsi_0\n",
+      "truths: 625 d_0\n",
       "uniform\n"
      ]
     }
    ],
    "source": [
+    "npix_lowres = npix // kwargs_pixelated_lens['pixel_scale_factor']\n",
     "masked_lower = -10.*np.ones(npix_lowres**2)*mask_lowres.flatten()\n",
     "masked_upper = +10.*np.ones(npix_lowres**2)*mask_lowres.flatten()\n",
     "\n",
@@ -398,20 +399,18 @@
     "    'lens_light_model_list': lens_light_model_list,\n",
     "}\n",
     "kwargs_init = {\n",
-    "    'kwargs_lens': [{}, {'psi_grid': 1e-8 * np.zeros((npix_lowres, npix_lowres))}],\n",
+    "    'kwargs_lens': [{}, {'pixels': 1e-8}],\n",
     "    'kwargs_source': [{}],\n",
     "}\n",
     "kwargs_prior = {\n",
-    "    #'kwargs_lens': [{}, {}],\n",
-    "    #'kwargs_lens': [{}, {'psi_grid': ['uniform', -np.inf, +np.inf]}],\n",
-    "    'kwargs_lens': [{}, {'psi_grid': ['uniform', masked_lower, masked_upper]}],\n",
+    "    'kwargs_lens': [{}, {'pixels': ['uniform', masked_lower, masked_upper]}],\n",
     "    'kwargs_source': [{}],\n",
     "}\n",
     "kwargs_fixed = {\n",
-    "    'kwargs_lens': [kwargs_hybrid_lens_mass[0], {'x_coords': x_coords_lowres, 'y_coords': y_coords_lowres}],\n",
+    "    'kwargs_lens': [kwargs_hybrid_lens_mass[0], {}],\n",
     "    'kwargs_source': kwargs_source_light,\n",
     "}\n",
-    "parameters = Parameters(kwargs_model, kwargs_init, kwargs_prior, kwargs_fixed)\n",
+    "parameters = Parameters(hybrid_lens_image, kwargs_init, kwargs_prior, kwargs_fixed)\n",
     "\n",
     "kwargs_true = {\n",
     "    'kwargs_lens': kwargs_hybrid_lens_mass, \n",
@@ -434,12 +433,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -465,7 +464,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -496,14 +495,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 29,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASwAAAEMCAYAAAB+0YtDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAADEF0lEQVR4nOx9dZwdRfb9qffmjbu7ZpKJT9xdgYQEd0hwJ8jiy2axhQWWoIu7awgQYhCBGHHXyUwmGXeXJ/X741R3TbAEMjuE37fv55PPZN6r6q6u7uk6de695wopJSyzzDLL/gpm+7MHYJlllll2rGa9sCyzzLK/jFkvLMsss+wvY9YLyzLLLPvLmPXCsswyy/4yZr2wLLPMsr+MWS+s/4EJId4QQhxzvIgQYrYQQgohUv/g+Uar/jP+SP//pQkhlgkh8o6xbYdex+8Zm2UnhlkvrJ9Ymz+a29r5uNOFELPb85iWWfZ/zawX1v/GrgDg95PPpgP4x6+0f1C1P/g/HNOfZRMBdPmzB2HZ/x/m9WcP4P9Hk1I6ATh/R3sXANf/bkS/bUIIBwC7lLK5vY8tpWxt72Na9n/XLIR1DCaESFXbxNlCiClCiHVCiGYhRJEQ4jEhhNdP2h/BYQkhlgG4RP1ftvk3Q332Mw5LCBEvhHhCCLFZCFGlzrdTCHGHEMJ+HNdinKu7EOI/QojDAJoBDFbf+wgh7hZC7FDnrBZCfCmE6POT49iEELOEEFuFEHVCiFohxB4hxKvqBWhe+y/xREKIaUKITeoch4QQDwBw/EK7X+X3hBB5am7bfnaOEGKeECJfCNEihCgXQswVQvQ6xvnpLoT4WAhRoPoXCyGWCiFOOZb+lv1vzUJYv89OBnAtgBcAvAZgGoDbAFQBePg3+j0ELg4jAFzU5vNVv9GnF4DTAXwOIAf8Y54M4BEA6QCu+kNXoO1dAE0AngAgARSpF80CAEMBvA3gWQAh4BZ3pRBipJRyvep/D4D7AXwJzocbQBqAUwH44DcQphDiNACfAshTx3ABmAmgPV4K1wOoAPASgGIAGQCuVOPvK6Xc9xvjigDwnfr1BXCLHgmgP4BBAL5uh/FZdjwmpbT+tfkHYDT4B3xbm89S1WcNAFLbfC4AbAdQ9JNjvMGp/e3P2nw3Wx2/7bH9AIhfaPs2+HKI+4UxzziG6zPOtQyA10++u1l9N+knnwcDyAewrM1nGwHsPIbzLQOQ1+Z3uzpWOYDINp+HgC+II67jl+amzXd5bcekPgv4hXZdAbQAeP4oYztVnevsP/s5tP798j9rS/j7bK6UMs/4RfIpXwogVggR2J4nklI2qeNDCOEthAgXQkQCWAiitf7HeYo5ktxZW7sQwG4AG4QQkcY/AN4AFgMYLoQwnAk1ABKEEMN/53n7AUgC8LqUstz4UEpZA6Ka4zIpZQMACFqwGn8ZgD0gSvotq1E/TxJCBB/vWCxrf7O2hL/PDvzCZxXqZwSA+vY6keLF7gRwMYBOIJpra2HHeYq9v/BZVxDZlf1Gv0gAhwDcDWAugO+FEIUgWvkawCfyt4n2dPVz9y98t/O3h3x0U1zbAyDqDPjJ17m/1VdKuVwI8RaAGQAuEEKsA7AEwIdSyuMem2XHb9YL6/eZ+ze+++kL5XjtPwBuAPAhyIGVgrxQXwCP4vgdJo2/8JkAsA3ALb/RrwwApJSrhRAZACYBGKP+nQ/gXiHEcCll5XGOz7DfCsD9qbMjGcAKALXgS2sPuI2XAOYAOCoKllJeIoR4DMBJIOd4K4B7hBCzpJTP/pELsKz9zHphdZz9XqXEiwCskFKe2/ZDIUSn9hvSz2wfgCgA30kpPUdrLKWsB8nzT9XYrgXwHIDLADz2K90MlJr1C991+4XPjBdfOMhZQZ3LF0AcgP1t2p4GvpROlVIubXsQRai3/PrVaJNSbge5yceEEKEA1gJ4RAjxnLFNt+zPMYvD6jirBwAhRPgxtnfjJ6hNCBEAEuP/K3sLQCx+BWEJIWLa/D/yF5psVD9/6xo3ADgMYGbbYyjO6OpfaG9sXcf/5POb8fPn10DAP523K8Dr+k1TPOERx5RSVoNbSX8Avkc7hmX/W7MQVsfZGtDl/rwQ4mtwe7dWSvlrvMonAK4SQnwI8igxAC6F5sz+F/YUgAkgshgLuvhrASQDGAfGa41RbXcJIdaA6KMQRDtXAmgF8MGvnUBK6RZC3AzgIwA/CiFeBsMajGtL/kmXJeDW7n6FknIBDAfjxsp/0vYbcKv7thDiWTDcZBgYjpKDoz/vFwO4WQjxOYjcnABGgdvej6SUTUfpb9n/2KwXVsfZ+wD6ADgXwFkgOpiJXyeCbwFQB+BsMN7rEBhbZBDB7W5SSqcKkLwW3JL+U31VCOBHAG+2af4E+CK4EQxJKAVfyv+SUm45ynk+EUKcCeA+MGyhFAz7WAFg0U/auoUQpwJ4GuT0WlWbUQBW/qRtjhDiJDAm7m4Qca1UbZ8Fw1N+y5aB92gK+AJ2g/fnNtXfsj/ZhLUlt8wyy/4qZnFYlllm2V/GrBeWZZZZ9j81IYRd5Y1+dbzHsl5Ylllm2f/abgKwqz0OZL2wLLPMsv+ZCSESwaT2V9rjeB3qJQyPiJAJScnwbq7lBzb9vmywM4siwBhRKz3ILm9+7uVh8r+0awUS0dIAAKhW4TGhdqbGtQhvAICnjT/Bz60Cu73Ud9X0iNv8/Pm5fwj75uvsG0cys0jsTo5FGiE66hhoZibOnhod9tMlRgVTN9cd0dYYk4/Q8ZhCXZPTzvEbR7HVcWzuIIYp2dpEFdmM+FM3+7psPK5dtdldVGe27RrN47YqtRfjMN5udT0tTUdcO43Hb5ZUsHG6+bufg9fu1Ub5WTiPlM+qhw8AwNeLbe0eZujIhpo2rTiKfS1MSeysMvaEjeeTHp1MIH1471vVGIrrGPeZ6s85bLDx+vzdbaINHL5q/ByDbwufNeHg2DxNvGfCP0j3aVXX4c2+LruPulZ+vK9cJwVkBqnrV89hq5r/RifHHaoez5xqnZ3krW5OUqChCqSO4WIbl7cOwDeeWW8ju0mN1xXA0DbjWbA11Zp9nD6cxCaXG6UFh1BTVXlcWRdJwk8246hxwwCAcrTuAMNdDHtJSvlSm9/nALgdQBDawTr0hZWQlIzPFy1H8t4FAAARoK/hx9CBAID+YZwoe8F2AEBFIj8PbyoCALQGJ5h9fHKozvKZh0HTp4fyDz3HNw0AUN+qH/7etZsBADIyhd/NfRkAENCdMk+ePicBAPJu1OovcU+9BwAILNnGvg6+3FzhDBWy7/kBADBygY/ZZ+ks5tfad6/gNUanckzeSQCANC+dbmivKwEAlId15u/qMfNfysWoeuRlHKNDv9h9lGqLvZZ9KwM4H4GqzfCHlplt19yQCQDItzPe06Ge9oQaonPnfkYf2PpPMfvAzT+U3U6+xErq+ZLoFsVrj/TSqjGOkj1oa6vtPF+XCP7hh9Qd4nl+/EY3UovU5H29AQDfTeI9EoGhAABZX202dXYayvHX8pwPL6EyzGt9uVBtCOgBAOhbp6MoPHFdAQB7mvlC7HJgIQDAnpABAGjZynvmnT1a9yngcW0JHH9pMNuGe/PtMeV1ffwFo1SwfFg8AOCgTyIAYFMxF4pT+THO/izf7BMXyvl4eoR6Mbm5sIpytilNHmq2bVEv58RWPu/unYzcqOx3FgD9LPhtX2j2KcxkTO32kgbcfPYkHK+1wIOzRdwxtX1eHmyWUv5iIr4QYgqAUinlBiHE6OMeGDo4rKFv375y5cqVsDdxxd3RqAOH5+8pBQDc0YUPcEkA/8BjS/mwuMsKAAC2kAizj0s90I5i5qUWh1KJN/rAcgDA4gA9j/e+uwkAsPoWpUO3iTd8dcrJAIARLv7xtSb3Nfs0q4fH+ENvdvFlasxYWSMfPD8v/UIR6qUT5ce1wNHAPOLRr/CPYtmVXc22tQ6+FEIPrmFfY4WP5Qv4mvlUTH5hvA4ql758ydsr+bALlUGz15d/ZDXNWoBhoItB4tvvvR8A4PMU4znT3cUAgB9bOJdpofqFG+nhym07zAWjedtqni8smg3GzjDbvr+d13bmdr78/bJ5P4zFp1/OPB6r9zizj3PZ+wAA73S+bFzdxgIAci4/EwDg++T7ZtvUVt5z6UXYsqyWSMJAcINCea32Ep3H7VEvEo8P5ymvlS+ujPINAIDqJI6tyaWf+zq1sLWoz3o5cwAAn9YyOH5aur/Z1qXQsIEeHSXM4W7+cTHHlj0SALA5sKfZx63+xvrauMi4tn8PANj/9hcAgMCndZxtfSvvp4GkOtmqeIygGHUsft7y2n1mH//LeH9vmrcbn999Acpydh4XwooRPvIcW/wxtX3Gk7fhN15Y/wLj+VxglkAwgM+klBf+0bFZHJZllln2M7OLY/v3WyalvEtKmSilTAUDpr87npcV0MEIq1/fvnLl98shNtC7aeui5YkMfmhdA1fGjI9mAwDCrrwXAFCulEIqmvQ2L8KPnEDklrk8Xleu8AsruCJOatlktt0UwXNlhnOFNFbT8uvOBgB0fupFHqNEC1K60rgaf3OAqKNbFMeQX8Mte3e1TSpvM6bmmacBAHrdej4AQAycBgDwqiIiun69Vjd++CRuBQOamd9bACKueDs5E3sdUaf01vUsDOQgfQKPGJvBoZyVqLkHey23FTgyPQ7uUKLXEiVeEG3THJBXBTk8VwT5uxd2cKsT5E3EWNGouZmbM7hV+6yCyGd6A9EYMjlv7sAoAEfyOZn+REVy7ecAgNfPZo705buVmGeB3maevp68zafdubX09KUgqVDb1nIXkVfkti/NPnld2CYliPPsUmtyg5PzElm194ixAUCeh+NPCuLxalrYtlYhr+SNGgHlZjMXPW3rRwAAWza3Ywaf59mnBFl7TzD7tHjz+AGl3Ak49/G5NLbi9upDZtuvmrjFHJ8WCgBwbCV9sjeFSDTcl9cVXbjO7CP8eXx3US6GXHoHNuzOOS6EFSt85IVeCUdvCOAJV+6vIqy2praEt0kppxyl6W+alZpjmWWWHWFCAN6243rn/cyklMvA1KfjMuuFZZlllh1hAkff7v1Z1qEvLA+AVnihrudUAIDPW7pMX9ip3EINspGQF+dcCgDY08ItXGkDIfeQQwvMPutT6NmLVkT8wYfuBgDsPeshHj+mn9l2jPIkPdD5cgDA9ufoAXw4QLm7FZmdE6H7oJZbgugAuq79lYdmVDi3JJvrOH39XDlml7IPuT2pU7uw8KLNAIAdQSSZnx6pxRaqlQ97XpFNHZ9bwUp1vpRQbssCbZpIP6CcjHEOPlGpodwubipSZHmx3tI6MwYDALaW07MV6M3thL9y+a85xLmubNKev8vdJPq91DbyukSOZbd3KgAgr0pvH6WN5xyQwC3JfWspZzW5llvloZIkcxehx1/2zBMAgIBZ/HnpXOV48XAb5uk02Gz72ooHAQAfB9wKADhXEdy5AfTmpTgPAwAOZunaFekebqPdoJfL9R6PEXoO6+J6HJyv3a3aQ90liPfZveh1AEBEf3ra9rXQ2ZGR2dtsazhsD/Si165JbR+dbs7BgBQ6VQo8WuzUz802fn7c8hf3OwcAUNvMzztt07VIRoy9AgBQ2cwx7QwjzTHGh/NuUAIbg/SYekXxml4rjkC5+KnI6h8xAbs4Md9YFsKyzDLLjjCBE9cb17Gke3YvuXrJfNy5kq7ax7s3mN85Y44sDmw/QFKxRMWofJfLPkMSdZBjei1JzAPBXNmj/Pn+tav9t2/uGrPt1+OuBwCc8iMJVCOWakMZV//+ykV+/md5Zp+PR3Futvtz1ezeQnFLZxRFP7dWchX089JEepd8Vomq7TYRALAwh+MenRrKMXp0wJ9wETV+UECyd0QK2yQcoFimiGbM2KImrT03LJErbGDpDgDAsunXAgBCv6YqS69SvVp7GlTQpAoLEClEeQZhLw4Sdf4YrlFNuB/bdjq0DADwhuRKflFPhjXIJa+abb07M0Rksz/nv/uOjwEATcPpCJq9mPM1a0Sa2SdBcj6KbSTUYwUho9OX99X30Eaz7aFIlhJcmjkAADB+Pwnt3SqQc9iOdwEArola9y+gjCjsezcdC0Mi+SzUCiI5r/eJuA6cfLvZJ7uVRPx/DhOpZ8cRLY0O4dhag3RM0vJ8zmlSMI/n9wirrTXfRadNlUKrg4J0sKmtkGNyp/M6GgVR/b5K3v/0NmElQW6e072MO4DSkdwR5FUTJWdFEE19uKPE7HNNFseybcbFuOj7H7Gzuva44FGCzVde65t0TG3vbdp/TKR7e5mFsCyzzLIjTBxDyMKfZR2LsHp1l2u//gi5j1AX7pZeWu331vHkJQbHcQW54H0GLj4xnat3UjXRlGyTxtCiXO/GquzMJeow0i5snQeYbTc0c0X3VzyOj7ojsSoXqKpF8RhtMhICXiMn9kQ3rqLTe3ClTQ7hihgtiBCdX+vqVGWTqS6cXEbXdVkcOTEjttRIMwGA6FpyX85ohjcY7v8uxURJ++OG8dqDdTrS57sZzf/mKnJNX/eiS9wI7MyJ1tecoNz0RjCi4aY3rjHTyb4HfbXIZ6KDq/6BZl5jpwIGObqzGBDZ2maNK6onmjCi98v/+wAAIOqKvwEAKn0Z7BjipSf1+wJyMVmRKiREBd9228sgU3uUdqe37Caicoy7hG1VJTUjuPWSrxhY+s5gHTZRFZcNAChr5LWG+HDio/LUdXThdRi8HgD0hQpQVeEj++/iPex0Pe9764HtZlvvEWcA0EGsY5o2AwBEIBFiTTQDRr/Lqzb7nOZNjcaPm1IBAIMS2Tfy68cBAL6TLzHbugOI8pYX8D6Ma+W532nh38f56eQUpU2jeo9CzO9vL8P9F09B3q6tx5eaY/eVN/v/VPj1l+3W+n0WwrLMMsv+PKOX8MSEWB36wmqEAxtlHOpnPQcA+HDne+Z33g6uEu4fyas8OvVUAEDUoqcAALIbgxGdnXuZfXz2E4m4Y5iWciCEHE3nkrUAgHO+1h65987gCtigUiuCK+lN89hY3q/sAXIan5z2gNnnxixyVTMHcD/fpYFcRI6LnFae5IqcPkHnH1Y2ETG0hmcDAFoUgui09jUAgN8kzbe49hEZFvoTKRpg1why7e1HBONVqr2QZ3XppH6GAgBEM/uur+N19S/VAYXuXQwcDR3IYNYX1/H3O+2cH9cQerpQr714o57dDABYdgu5w7rPmRO5yM7rOSNa84759RxD4pa3eZ6uvA8bmvh5duDPE2hH5BFJvVdDju/8rrwvdf2JXPC6Tjmx+xJNeCk00eTkBDkDeM9ePos/G9psEmYvIB/1xEQihAX5HG+FqzsA4MJ6phNl+2la2bWJ87E163QAwL4bnwcAdPZlEK085Uazbb3y7DoayFHtiuK9+lqllnVqrAYAZITpdJ48Hz6zw4x91pxZvL4+HBMKdbBsReoIAMCoQ/MBAK8GUUL/kh68VtcSPkdywpVmH5+KPPZJTUSQT/v8SZ+oW0ILYVlmmWVHGDmsE/ON1eHJz9//sBLrirjq9Y3VMSOBRURWBeFESf7vkecSl/DndZ+Rn3otcr3ZJ7//BQCAIG+uluE+nOSvchhfdFpgkdm24FWiuoTLbwAAlISQE5irOKErEzkmd1C02cdeU8gxNPJ4TRvovfM6nTE9NrVaFzx6r9kn4c6HAQB7lNpBtxpel/MQV34x6DSzbZUkKooqYmLuQkFP6bhYXk+jF+dn/j5dk9RIvTGSoIseuAkAkDST3qTX6lLMtpeF8/qb4unp896zDADQun8rAMAxlsiw0q49r1tKyEeNDaQ3b7ukh7LbfqZTCV99z368jbFUg9/l3Eov8l6vHeZ1XVxOlYZtPc8x+4QoBJAuiUjqA5lkaySYt+X4Qsp4z6/fQC7u8rc4772fexIA8FkVeclTS9qoQYzgM1GvUnGMn8bxDVWLwAKdtrVQErWOTVYoXzn1G1Wy+4fbS822V3Rjmy8PEf1OTCfy+XIv0fzQJM6lV5tI8Shf/t9IEzKu8WANubfoAI0boiTnv0Gl8wTlMt1JRtPTamvgeQzlEABw5/J+NvSZhrGjhmPzxo3H9bZJ8fKV9wSlHlPbq6r3WByWZZZZ9ueZDaLdU3PayzoUYfVOjJYLbzgHL/ZlTNRtw7QnokxxPz8epgdoehxXsBpfJqlWqgRjI6kV0Im/Jyce+d5dkDUaADBs74/mZ0GCq9nqUh7HEIPrFcsVs7SB5xvwo/b4XethJP3wTEY8n9GVYylU3jEDNmeWtUlEVTFPUoniNX8/l23PIEe2v0p7tFyKD+nVQCQhDSG5EKI85zZqN+3vc77ZJ8tGVGckCZd+RYmSiGFDAADuobpQtBEz1FddY5iqTl/oIgKKXkquxmewzkdd1MBrneRLdOnKJ2/X2JdJ3GV/u9hsK2eTT0ndRV7KS0V5N8XQs+toJVqwtWhRQVF6ZFWzw/FK7kXxU6nr3jK/8+rLxOICX3oOa68jUguMCwUAJF1INOVJ1wt8kYfIw7g3xt9dJIigxR7ynjmpWvKmcyPncrk7FQDQ6c07AACxN83mNXvpurBbSnicCQ1E+obemWsHdau+SuBcjlPJywDgv5H3qFnNoX8NE+HPml8NAPhsjNkUbj/28yhvYV4LUWvSGkbhGzpezq3fm30qh88AQM/3+FEjsHnT8SGsNC8/eX9o6jG1vbhit4WwLLPMsj/PTmQOy3phWWaZZUfYiZz83LGBo1kZcvUr/4ItpfvPvpPFdN03bKGL2XPOPQCAe5Sb+skpJKTz63Sibq5KxB2VoFQgFSFpaB29n6SDKM96+jwAQPFEBqsGvfV3AMDhc2YDAHopNUhTzwiALYiEam4SXc0pfkqZUmmJG0qVkZs+09eh9K+W5HNsIb5cEzp9wERv19WPmm2jt84FAFT3IREfqqSxDU0qQ8eqrWzw6gAS6NsUOW4kZI9N47YlZofWhtqUzCTeAZLbMFnL+Wk9wC1oyQ8k+xNv0U4DWzMdDLUxDIAMOsj7URjLuSy/7HSzbWx/hjHYb2AAZGQlt4+uMG71bblq22Ro4AOA0mz3JHDb6PTn1scgx9tSJzmV3Lb3LaaCLNKZCiRVErGhhd/WvNX4c53cGqblMGXJXcWttFcfbgVL/bSiZkw+t4lPVjNEJEUllJ8ZwMDat6p12/OVT8OQkC6q4z3rGU1nREw1t5cHHtf3OeX+OQCABp9QAEBQhQqpUc9p2zoFubcy+TltDreAO2uMJHcVMPo2nVBFq3eYfcKUkmxdqwdnTByF7Vs2HdfrJsPhJx8NTz+mtmeV7rS2hJZZZtmfZycywurYF5a3H2ypPXHAmyTqDwerza/OK2V6hP/0awAA18/nSjVAIQdDOzutotDsU6aSdoWqPoLDLK7Q2FlpcR/UibReNq7sOYdJPCdfyABRH4UwvyinG/m0GO0IKIyhvruvAqFeFUSB75cTFYxL59hKszXqqFKSNJPdXAFzAohMnFdxxU2s1Gke2ztTZifLRVRghElAVbNxxRJVigIdODrExoIY+7yIbkanEQXGNzJVp3bHZrNtspLxkbW8zZ4kBjA6olI5lkGUZZG+wWafXTamH3VWKqg7H6AiaNIrnwAAYu+8xmzrUuPyqWDalCuf96w5iuS7b101G/aeaPYpmM2wkvoifpf7dyZTZ0USobSlTvrXKLQbFAoAuH8T0cwdI5jy46308kX+NrPPnvjhAIDMPXQEHOpOxGt/7DoAQIxqF5OYYfZxpxC53RSvpHMUzPMU8/fTsrSmfoGSfYn0Y5sue6nljnjOpcef92P++Y+YfU4D5/fHXF7z/nKivxuK6bQw9fIBJE2m88RQ4O2ex9oDGxPpgOis2mU8/67ZZ6965h5cuAeFNUdWMvojJgTgaFPR6kQyC2FZZpllPzEBcYJCrA7lsPr37CrXfvEW3KUUXnP2mqy//IJBiI6JFO7LvYuhD+GPM+0j2ENkVCG1vrkhI2Mk164rIeex5lA1AOCaATqR1k8lSBtSKN0ij6wF6Mjn956QGLOPkTAdFUCOwUikNUotGQm2Pl765kZUU1LFFZEKAGhV9Qi9V5NnsKlyVgDgFUk0s8DFoMAeSjO++d4ZAICk//DaDT1yAAhuIQ9l6Jrbasi9HXqV8iax40eabVsLiLp8TyUqemwzea+b6xloaaR3NLn08Q098yQbQxHkliUAgIpVDGBsvebfZtvYdarCjVqNPQpRVW0n7xh99Z0AdEk1APA4Gb4S1JcpLbLbKACAa/Fr+Kl9k8XA1tP8VbmwfQzCdShBPY+SpPmiUiPESH/O99BgPi8NfkRHwUqOZ48/MUonh04x2u/kvPspFJZ4K9ODbDWsLpT/ii6zF/UAr8Vbaa1vjOX4BzQRObsr2KdtCbtdMbqMFwDc+QXH8tnF5Ann7tOSQ1P3MKzDR6WiGeXEchx8lhvVs9DdR/fJl6EAgJSClRh8wY3YsHPfcb1tMn385dNxmcfU9uSDW3+TwxJC+AJYAcAHBEifSCn/8Wvtj2YWwrLMMsuOMAFA2NttS9gCYKyUsl4I4QDwgxDiGynlmqN1/MWxdSTCSuzSU9700ufwczD4c0KGrjFoBITmqv14WojynKi6e0+sJsd16yCNgIpbOKmxyllU7+bvL65j2zvji822h6LJUyQ08zsUqlp2SURclX5EO6EbPjX7lH/PwM3IG8l32VQ9xcuXEn28Mp58xRel2ls1XKVmBC/lqvyIP4NP74tlsKDhHQNgegHz3FoyBwDSnOTp3KFcVR1l+83vpBfPZdZtVF6pQ8FEDhWNOpG556Fv2TaLSLaonqgsMYgopOFeotmUf2jU5PqeXJX3QI57vZvz0ukLyk5vmKyF78YGcT722XhPYhUSDT7AeTPqLO4Nyzb7BKo0KsMbGPI1kfWmoUQ3bdO1fEvJWzZEsU7j4TqOP307vbK2Xm0iLpW90YXXOnMXU4mMen7eRUQ1rvBUAMA7OTqAt4dCtH3e5D0r9iYHGldHjs7m1LLQrlBWtVlXR6Q/yMG0HaEqTOcpMcl3Nmuu9d5OStdaPcsGMnz5IO9D/wSNEPtKokm3Uaw3fzOP70ve6+0q3o/z0zTWqDHqW9YdwuCTz8SGLduPC2F19vWXzyRnHVPbyfs2HbOXUAjhD+AHANdIKdf+kbFZCMsyyyw70oSArR05LCGEHcAGAJ0APPdHX1ZAB7+wwv0cOLdnrCnaFtsm6dO2ld6QgEzWcxOt5CBcKsmzWtXDa4s2/MK5CogN9AgtCSZ/M6uSNe92ddNSLmHGkq7ivTxZjK0yvDEh4JhWJGpebed4epyuyyd3ImOZJPtKN66qdUo6+bQgLQ9SLrja2Sbz3Pep8bauY4Kqb4BeTY1E660qt7ZFcUktMcpTp7yflZ/rdJWwM5nkHOpDRLrDh2NK+4qxUPFdss22zoNEKPHKC9UUwe9iKok2PJdSOO6jAn0fzlDjc4URSfS0EQX4qiIhw2P0+FFNhNWlivPTFEyPaEMG582vkReWAZ28bVNJ4AjjNYp+REkJz1DCpeJezRfFqYIRBseWCXoFqweyluQnqkr3zA9uNftc8gXpkQpfHj9yvyr1vozPV9Al5NUuTNWX0XwuhRKNEvLL8pj4fXYG56B1yetmW8cQyh71Xknv5s6xswAASTEM0Eotocfy5sNfmX1kNJ+1A3H0aicH8Fm8IoXJ6XeoHQEAxI2g9zJmB72P1Upqe+xDywAA/72a93tpuUbSY8LUvHz0ItyVZTheEwKwO+xHb0iLFEKsb/P7S1LKl9o2kFK6AWQLIUIBfC6E6CGl3I4/YBbCsswyy35mv8NLWH6sW0IpZbUQYimAyQD+0AvrxAy2sMwyy/48EwLCbjumf0c/lIhSyApCCD8AEwDs/qND61CEZbMxJCDmMHWlPKFjze9EGl3VMXYSnF6VJKnnN9Ct2y+JBHdOG3dxugohWBHHoLozFAksm0lAGwQvoLP1vwvkYjBabbcOtnLb4VbOhxEH5pp9RoUydeL1Fm49Jqis/XilDuGnwhmkXaee7Crn+PdV8Hyn/8jtXOP53KpsK9Xu9EkNvMZsVTEoMZAw3LaRZdvtESR/g2fcafZx23juD3cQ+l/YQmeLrf9ojiVCVztxZDJ0AKpk/VaVzhOSTM2x8ECGRPSVepv36QRqTbV8w63xKctJituvYbWZ+uf1WBwBqnLMjNkAgCblcg+ryQMAuCKZ3mE4KwBAqtQcg1R2R3KLk3od57DgqVlmW3EGt35bGzjvWZGcj9gmjvu8x89kw1Fa8dW2k1WLPOp+NmdyOxaqVDTcivi212qttNJTqEGfuJUOl+kFHL8thulcWwZcarbto9RsvaZznN2qGKJT2MIt4Suq8s5Np1xm9nEp5YV0pQxa8xGfCf80zs/MAVqNw9Dfj+nMANLgVm5Pl/+dW+cvlH5bmJ9O54k4i6obLz91G2pf/g7HawJoTw4rDsCbiseyAfhISvnVUfr8qllbQssss+xIE4BoJz0sKeVWAH3a5WDo4BeW3eNCYEslhA9X5gqnJvYaBAP80nKo87MhiivMxB0MiPRS1VQaO52pD1hGMneUqhbduJBufL/RTJVxtJn057YTXczIJhnrVCtIeosiPFXlYVtnPbfj5pL4//pqkta7K5j2UAGivKwlRB9f99Kraf9PWGmneBoRVd15DEIMUGhskne+2daoAJS8nwm6G+OJODv3pqbS5mKisV52rS55QNWnuySY7u+675Wi6dk8b8Di/5ptfXuT/DY0lqaHMOjUtY4EtOjC4ERbm9zkc9cbOvtKD//MGQCAkicZzhA9Tc+/DOc9EaUk0v2iiGzd+5hUbVOqqM5l75t9KsepFBkVBuCo5u6g4K1XAACxV+uwCdFEdDEwhvPk10R0AYWOfROJasyUJgCVnUYDAHIqiHS7RhJBO1OINg1tqh2dTjb7RKpA4Nwe1JX37s17lST4XPVxV5ttPWlE6I5yJqgvGjsTADB0KxOoL99NMt4WPt7sUxhPhBWt5j3oHJWe5MtnPqtRh9/YKonYdv+LoSZfziTivaA3n0+jSreRhA0A5Q/wmfV0Cce/fY+ZLP91EwJ273Y4zv/ALIRlmWWWHWFC/C7SvUOtYxVH+/SV879bgc93cUW8KlVLxRT5kKtKqGWIQOMKhip4zqD6o1HpuDZaS9OsPswAzomBym3uoavXkO2wVx8y2xr9/J3sYz9MJ0XzFgY5Np9KvfCQJl1R11ZNnsMVQ+QgFP/ydeGRc9ZW8bTORjQUsodo70Un0y+uSiEystXrSj554UxGTvRWaTYKUTQvZErOwYmsjxfWZtWMUP83UoncZUSILvUz9/NvzbZuxYd0vpSI06sLww7cKvjR0Kw3KlkDgJfigBBL97pQc+CJ5u+Vrz1mtvUO5rU6G4g8A5PIMVXuYOiI3Zs8y55PdRL64Adn8LsBDEyt8uG9ClnNZF6vuFSzrQgmMvFUFh9xrfY+RC/fVTPINDtWB94ax8FIqpEKp5LsKVfhJbs5ltfDTzL7XB2ljh9IxHPbaiLrs7OJIAc1bjXbNiik5usi+j3s5G4haQ/TnXI6kftL264DkCv7sTqRcR8NGaRvSvj7SdH678CzgSk/RvVsIxA4tYSqtoairTOln9lnXzXbhDx/M6a8Og9bi8qP623TNThIvjHo2BRjBi9ZZsnLWGaZZX+iCSv5GQDQL7u3XP3dQsjt9BKijw7SNETxfBuJvmp9uLoaXhIjjUW01Jt9nGvpTfNRXI2R8iDcXLHcoVp4bW8d+3fez3pvXkpGplUFHwqFzmzblph9vglioN94pc9tX8UEZkenbABArj9RR4pHV1UxqsAY/klfhei8qslNyEadtNqynR4+nyHkrAwht1wHj+Gr3MaRP7xq9jk4iJxJ56rNAABXIhHcgQb7EZ8DQPNWBk26TmFlna2lRA5DGragrR16QwdGJl1KPs7mQ+7HmNOt1/MYPZ972mybcx89hiEZRCLh184GAOTfo3iq/vR++vXQQooFHzP1J24yUZK7inPnSCcClsm9zbaeDbxX2+aQA0seS+9mcBcm5m7rTe9al3CdGmVUq6lRlbyNis/74piAXKzSe4bG6z4FnBYkbPoQgE4pKu01ndfVBuF6K9RuCB0acjK5NvKcGfXcIXh82iQ/C/KmaYv/w/nIZqCqu821Gubyocf2sBKqTPUmF2fLIzI0qoFneDeafYwKO77L38SwWY9g476Dx/W26RYSLN8aNuDoDQEM+OY7C2FZZpllf6KJdk1+blfr0BeWq6wIFS88gMjLmEphU94lADgQwDSXNMVbHKrkChOqVviUKnJYP3p1NvsUZbJCzMlRXBGLWnk5Ru25ytsvMdumP0FeyFND/iA3i4JrlWVcwXpGEVHcWaL5nH8HUJiu1k2PpV8L+ZBiVdPQ/iDTb7bOesbs465km94hqkJwBeWJnfm8Vq/UrmZb+1Smo4hinqfqU0qspFxOz6JnGeN1vJL1NRteImcqV0DPfNYETB/Ha3W2EfvzmsQ0nmoVHzXUqVZ/5d0z0EHchDaSNKpmoddw8i7CyZW8+43kVHbdeovZNvMCetpsIbxnG6aRK0s/ORsAsPFZppcM+P5us0+SktfZfh/rN3r5KQnpGUQoy8+barYd9QLlrLtdpJKcFX/jaSZ/lPw+PbEBF1xr9mle9hEAIGYox+ZuYtv0zURPcQd5P7zHTTP7xK4jqvbqRfRiSDobuyLb0jfMtsjmWJpjifaMykfpOeRCy1J4jLZ/75nLiWB9hpE3c0bx+ZHqPAfr9S6nvJrzbXg3v8wjUjxViQxmqMpHu5u1zFLWXnofbYkZEN4+OG4TAnbvE/OFdUyjEkLcLITYIYTYLoR4XwjhK4RIE0KsFULsF0J8KITwPvqRLLPMshPdhEJY7RHp3t52VIQlhEgAcCOAblLKJiHERwDOBXAygCellB8IIV4AcBmA//7GoeAVGYPIS282q9e6Q7TAXpSK+zC8Or2ceQCA8g+IMtwXkUPp79RePE8c0dfcA1x1piWry5H8uWuzjmb23MCo5dp/EMX0DOJqbRRxKKwnh/X3cVo693BLKgCgqYHfxeRzTB8GcwyX308xt6U7dRzQhRl8b4sGclVFEVyJYxU/teve+8y2nZ8kOvpeUsBv2EjyOuIAPUJ3eSgO92icXk0HlW0GALhATsa7Ez2NDapKtG8/HV9k8H54iqho+fmUiBmWoxBFokKTbWLPVl0wCwDQYzGLIfgrAT93HbnELi+8abZt/eJZAICtkTydR1U0jpjIMQzuQ44mT809AAQk0BPX5QrGc316PmPZujzAtl1XLTfb2os4D4YwoPDjNXrU3AbEMgLeHaDrBppywyqiHTY+V4bXLWAAj1Xh0NWug6Iorb1eFfjoE8br8PuA8/VOH51EP8NL1bVUz4R8gPPkczJj6JoSiMaD3p1t9mm+jPJE9laO215H3q42hMFU20qrzbZVCkEbnklfOxF5saQnNL6eCDpLecIBYFEwz1nV7ESl/Hlhjj9i7anW0J52rK9ILwB+QggvAP4AigCMBfCJ+v5NANPbfXSWWWZZx5uKdD+Wfx1tR0VYUsoCIcTjAPIBNAFYBGrbVEspDY2LwwASfqm/EOJKAFcCQHJC/C81scwyy04gExCw/VVJdyFEGIBpANIAVAP4GJSHOCZT2jgvAUDfvn1la3ACfJwMojRc/QDQGhEKAPAoZcW8QBLNAZeTnJW7mb5St0krq/rGMlDxjF7cHl2/hITj5G5UmTz5Ex0OsF2y7fIcpnf02r0MABAxgCSvawm3d/bpWltpdRm3mgMXMk2i9ZL7eZ5WbgHf3EFof2FPXfWkQW2LZi/ndw9P4pbEqNWX+vInZlu7UtQcGsyHo3Ujg1lfjOV26bHODJQs9kkz+0Q1UG+pUlVvCe/M5F7vJepaFVkO6EBU9/V0p/d+nzXtZCdF+qqk7U/66y3bwAuzAQBLM0jqj31oOgAgdz4lj4pu0trr8w7StX/BYK5VqRO4fZGK6P7yQp43LEqnFo1+jwT57n8/BQDI7KdSpbYztSUuVWtnlX5OAl1ex2DVKJf6bguDYw3HgHuVrgtpG86E6eYFlGSa25mJ0aerLY5zCbe0ISlaUdOmQlx6x3DrbT/AZyx4PK99cphWxnWtVkG9nXmPut3PeV+lnpXBy5lKdnvixWafe118JoLLuJ17rJDPyy0OlQMcMtxsOzOmGgBwWCXpZzhV38//BQD4YQwdEZ8s0xpaT4zlsy3XfoM5Lp1o/oftBI50PxYv4XgAuVLKMgAQQnwGYBiAUCGEl0JZiQAKfuMYlllm2V/FhIDNcWJGPB01cFQIMQjAawAGgFvCNwCsBzASwKdtSPetUsrnf+tYffv2ld//sNJ0Bftt1ioTrhImBR8ewUoudlWgLrWOKMSjJDqMQEYAaPHiyv3lXpL4PWMYrNdVqpSajToI1KOqJ+eMYuKpsf02SM4BsVxdxfp5Zp+PArnyRQcQiYxKZoCeZxFXb4cirW3+OkiwOYXIZGkeV7rxaRyvl1q1jRQXAHAGkDgtupPBoMmz5wAA9rZwLEnKMXDoKo2aDOv0kqr2+xJJ/LfvYxDtyWdrzfi0/yjUtYlpIwVfMBAzZjCDTQtXbAIARPbSY1r1II/z5WESxHMaSUgvVEm/fa8cYraNvYrpTK2rmFC88u9ERM4Gzmm3s+kQaKnWwb5GOs+b/6VMS4kK8PRVN+TkTE2gZ55CxBaYyHkKn8wK2RtmzQYA9HmYaHjPf/Rjl3cPr3lCAueu5bM5AIDKXawg9PEpnK9bE8rNPh6lbLr/foZJ+P6bKGrhfj5X0QE6VOCkw6ysXbOdYTbh57EikaG/b9QVqGhym33SwXO5N/F5vLmOSeePnszA2spmrR6aWPgjAKA21SDSeZzYJUSkS3szVKXf3AfMPtvP5LgzI/xw6rhR2Lp543HBo57RYfKzM8YdU9vOL3zaoYGjR92oKv3lTwBsBLBN9XkJwB0AbhFC7AcQAeDVXz2IZZZZ9hey9hPwa/eRdWRqTo/efeTHC5ej06FlAIBdCaPM71YfIt8y002upKo7g+yW51UDAKZ25sr7w6E6s0/So0RjGQ9RzxyHVAXiHtSFb37rfrNt3ilMok4PJVry20q04enDAFJDQ95IkgV02MVnh7lgjUsPBQAEfs9QC5uqSOwZMN3sc0ilVET6HQmpv97H1fq8yGr9YZ1a5YPo6q8OpaBbWBm5rKoohkQEeXQaRsE/Gd4RP2k0x5tEPqoikau2z8cPm219k8l9eSUQQbnS2ObgLPI6rmamqXS69FyzT9VaIp/wmUQv9goiXyPNZ+U/NAfX5TQitYjuPE/lbqIYoeoUNhTw+sr3aDTzzkrylpeMpkt/+Y9MwE5S8+Vu8zie/S75msKFywAAiX//D9qaaKoGANR+rtfKoP7kM/ckM8zA+Jt65nsGjD55CufLs/gVs4+3CuatTmPQZ+AapgIZIRKtB3aYbXNGkIPralNVp1sZeCy9FApT4RSl/olmn+gDDNVwdx3N49YxLKbMm8ePatRcboEvnzmjutMyJV5Y2sB7NW0Hr3VZ36vMPoMXk+P7bvQtuOv8k5GzY8vxIayYcDn33IlHbwig09MfWqk5lllm2Z9pwlx0TjTr0BdWXasbKw5WIvBr8kRdbh1mfpdZTp5FxNJjY0jFDkwkb+RVxaTTRXt0PbkHnqLHx3aIybzN3YmsWpRXJvD0a8y2PfKJEODgamqLoHeq1pD1rSKSKP2wTYWamx4BAEztzGl6YClX6btHz2CDj4hm/Px0Lb1khe7Eurn82YOpHOeHE2U4d28w29p7jQYAuFUQYKDgWKRKgA2p4zUbHk4AaLmJwZrLysgLnZZCdBYw9zF1XZFm29ZhF6j/kSPJvY7ewAKFahqUyF3x5qfMPvHKa7dvGvuGZ4apNkQF2ws0wh03g0GTBv/YuJSc2HOvbwYAnD2IaKFgf5XZx0BS7y0nGvNTECivUUusGHaWm/zNRy8xgHRaNRF15m1EXmuu+jsAILavRjMBWdUAgIqpkwAAIz+cAwB4tj85LVFIL+sXGWebfU6p5bMRVsn0KddApu3YKijS957UScqXNpFTrYkmugwqInoqSCbfub2EHtJRS7QMj/tMcn2F93C+mu9gfHVWBZG0kfQOAInuPI4/hGh7lA/nzu6leNkpRHiDbNrzumYCJZ5PD6rAo3bNh/1RE0LA5u04esM/wSyEZZlllh1pArBZCAuI9NRjRtMP2HQp45rcLv0Wjx/EeKgKL67o3+xkHNO10VzZp31L1PT5KaFmH0Oa10iGtas41sBtTAZFJ721NviDxjfJazWfy9XZV3kj8wLo8WuaqTmgCKN4gvJQzh7NAg/2nUzqtY2kLIxowwMaY3L1ZXqKUMfY4c0Vs8ugZLOtdKl4NFXIoOxtersiLueK6V5LL2pmjRb9q82j2Fzfa+kZspczobmqgl49H7fHbJtfSzTq8yBX9pTp9PwEJBCR7v6EP4f9+wo9fuXx/HbqbABAd+XB6jydKCOtTvNpu+7nXBVu4JhSRrbR7QXgrxJ4l63RES9XnUbP2Iufc9xOl+eIPldM0cnnRUsoDXPbLsZZ7b6LcjYHnmVKk7fy3qbeepfZZ+OVRF8Zp5D/yw+jbE3cFtaqNORsTs3WNI+zsBoAUBnK2L/wnUT7dTuJGKOHXG+2PRSqvLCtRH/BSoomqY7cZ3ASr8+RqqWevXLoIRb3MEYr2Z9/drl2jm3VoWqz7fDkUABArEo+rpT8e/BX8V1GwYyUg1qosVxkAwAW2SJR62mfP+n2ItSFEEkA3gIQA0CCdQuf+u1ev24WwrLMMsuONFXmq53MBeBWKeVGIUQQgA1CiMVSyp1/5GDWC8syyyw7wgTQbqS7lLIIzD2GlLJOCLELTOP7C7yw/IOA3hNw+rUfAwDmPqoDIhNVhZJlFYTqV3pItNbHcas4dxLJTmeYJliLyBlDVYdH/BZuBWVPFfS27kt97laqQASdyiDNQKmCGbdRxyg4mfDck69d2IVdSNwmFZEcvWIt02yenkZi3VS1dOl0Eud31BT3VgqaIprbpMi3mVpx8MpH9TV/T50ko/x5w+VsE7SIlVKMsAnfkaebfXyVdFXr0ncAAOW7mO4RfgtDO16M1coLV3/F9JOqZKYq+fSkyz96IslrYVNBtP21wkOum4T/+DOpH+UTSpWAyEHUED88f6nZ1q22Revyee+MDeH9/yW5f9fVDA+YphRbAb0V/DULSdNOg3/PYbrOQxl0hFSrVKB3VvIePfEBXfvCrR0x0b35fMSpmoZShQeITpyXBQMZwhH0vdZKGzqCAa7eyllTPJ8hL2+P4RZ0WrgmuOP3MfhTduFcCj/OT2EwwyWiwW3+gtxms89kpUUfuopb6IZz7wWgFU67ZOn7+8kOUiA3OLkdjlTVor4eSLI9UwVd25SuGACcH8WXS47LDz7tgYx+H8I6aql6fViRCpb8WvtHh2YhLMsss+xIE4Dd+5hfDcdUql4IEQjgUwCzpJS1R2v/a9ahLyxZWwn3d2/j9dkMXOxj11rou21cGcelqwBCB5FViwo7sEUTLfjmrDL7JCqyHaqScWMvIoU9SvUzsY9euQxa3EBDoplz1ryPbu7qBaxWUqAcAgCQ5sVVxhWeCgB4fipJXkeR0ipycOXd2Eaoot9ABtx5yrmqrnbzu95KByrcXxP0XkqHShbtAwAkFDLBW5xBwtZIAfIU6mDWhh5Efd4uhgGsfJpu9YEN1FGfepl+dip6cg5DVNiBoY8lv3sDAOAfTUJ3/Rk6+bnnpQy49LuPidKlb7/AsfYhav3xEq3pvlKFRdx8LQNSC9bwPEmTiD4citcuqNJo4647RwMAnvw3x92sEEOk0kNb/NYms+3ts3gcqRwJB3fT+fDveqYLeddxjt3eumpO1GyS06KEO46CZxmaUncjed5T1jPw1ePbYvapbOF9tL9O5BN3GusT3m4jeq301/e3cjmrCgXs2cxzB9JJETOK4SAN79EhkDVdOwJ+vJxjSvmKO4D4w0y/qRtKTfo+9YVm214DeJwDtXx2uzRwZzEiWmm/qcrP4Zm6ak5kvZr38Ah4t0PSshDtG4clhHCAL6t3pZSfHa39b5mFsCyzzLKfWTt6CQWYtrdLSvmfo7U/mnXoC8vmHwjf3sNRUMXVzZ27wvwubSRRl88+7t1lLN3bO+rJqQx3MHBuhW8vs09iDNMhNhYymHHqHq6i4WOINhxtVhvT228oUZZw9XScQTXO6PXku2L826DVXVztc9OILrYdUsGaitKoUqk0fasPmF1ad3L1fCuSqUWX1bHaiedUBrHaD+mKNYUfk+NJuJgJrbvjGHzYtYyIqnQbV1f3hm1mn5hM1sWzDSaanLZ7JtqaV2We+X9ZzHPvW7AaAJCkPs+fz0DJdfOI7C748Q2zT91SBvXenMbgSSP4M+Y8BjDGJwWbbZ/ezMVy5emXAgD6KPRxQCVrP76MnFz5Us17GRV2Lj+XqS3hXRnmsXTOMgBAVKTmi/JXcF7jVQrRmZ8xcVmqQNjLvyWnNWea1llrfZ68k2MmU7G8bmegbeKnHEtJAc/ruUH/7cQ289nafc5sjkkFh3r8iEDNWocAJtiIfCYn8jpuHUR+0KOkevzP4fOU1qp5zbsv57kecJLz2xKcDQCIVsHR1V4xZtsEVcXa38FQmqY4Pu92hURPzuTn4S4djCtcRLA3frEL+dUazf5ha18v4TAAFwHYJoTYrD67W0o5/48czEJYlllm2c+sHb2EP4COx3axjuWw3C6466pw9h5V5WOSRgc1iqsSqmpLo0pEfXEBuYj+Z5GnilZa4ACQ8jy9Rym1RGr2YdMBAImB5ENya7XERydPsRqEQljRTNhtlAxeDcok92Or1/rsIpJ8Qqo/j5MBcieV8xjQGdSTq19rg0Zl5cNZ1+/yGrZtXkvE5RtIDmJniE7z6DyeyM15mIgqK4s8V+sGeqICFe/liNQrsMgj6qtYSr7rsEIFXX9kUqwtS3Mb7uRsXvs/iS4aQunH6zSSCCh9Jp01+x7+l9kn7QIiiH+9xXvjM4HIt2kxJVd6r9BoCQfoYU2frKpq7yMvFRBLZGLrQjTYpCoUAcADMZwzg8syENf05yh4J3w1wvLtPghtzajoIzZw/h9U1bXdr2rJocgzZwAAtjbxOL0UwnVPo0fRz5eck61WJxy/W8S253QnSvrPPqKYm3yIbB+cpj27SxY/CAAo6q6el0byauUOxVGqQNIJr2hv87fnGalVCt2F8virS4mG+sS0QZWNTHZOV1WiWn05twtyVZXzdM6tFFrnf4PN8M/moT1MCAGb3X70hn+CWQjLMsssO9IEYDt2L2GHWofKy2Qnx8pvb78I346YBQDoFq29O10EV5/XDnKiMsOZUDwogW3q1H6/rRckwMVVx15Pz0lzBDmlBTnc3w+M13yLETOVVaCqssQzDeP0r9j244uzAQCbS5rMPn2DyZ3YS5huIwO5MrauJ7ppGMd4po39Rph9xv5AL9SnReTXTk/k/BqxQu8e0g/C4P+yLmHG1eSADAThbXgPU4jGbM064diIE6vpQY4sRFXGNhJo7bXFum0ROSCRykTd/XeRX8m4gmhmRzKr9GQu05kSzacyUTesgjxO8Vv0cMXMuA4/NXcuEYgtiKt+aTrlgppVPFPsMqYa5QzTVWdSFzJeLH8yz2MINf6SdytKpbBsLKY3eFgtY/Mmfc9n4qMZrNrt66W3LwVK3ie9UCW7KyTt3kYUbutLL26Vj646c7CGnGrUU6pOpOJv4u+kx9isVA7gaUmBxpvT2ccQljSkbioCyBSGOnTKUVkLry2hkvF8jWu4w3A2EGEFT9S7hoZopv60KNI1tIlxWY0BRGlXf8r7/2YXjRC3JYwGAPQqX4PBF9yIDTv3HdcWrE9qvFz+j8uPqW3IpQ9Y8jKWWWbZn2dGXcIT0Tr0hWUPjUTI9EtxRh09dNKtV7m1ToqZjUwhUsjwZpKtXcXTNH9NSWC/FJ1g6xxHvsil5Fj8DnIFPjWeHsZ5hZpb6vkME1gPP0xJmqRmrlCfTSE68Ki4LIdd14M1asFFHyTaaMzluINOY7KwIYEz4JYJZh+jmvIZ0USMZS8waj34FnqKLgraaLat7MHV31XMOBrfgeo4Nt6WzU1EmT199WrtKsoDAIQl8eduL8avrVHew0k36IIGRWuJsPq8RqST8Rh/2kroHexRRNThVlwdABSp+ozBSrwwtDO9eDYnkaeRPMyLVTFySujOqTxZYb7kP7wVV5YRpOfUK4MI4q55vK8pyit422ii4wSX5hA3VYQCAD7fyjils14nQskcQmR18bv0uF46PNXsM6WE6MUzgNkD5R4i3QcNWeIA8oE7CrVsc9gdrFno8+qnvHYfjl+2ss0bPloWevpbjJFznUaEK1Tdw8q+ZxwxB/ZqnfAd48frcJXymdszikjORyHDep82fJHaCRiA0ygU4mPjcZ87XWVkrN1uduktiKpLUkfA5aPluv+wta+XsF3NQliWWWbZz8wS8LPMMsv+GiYEhJf30dv9CfanvLDK5jH5OfzSv5mfrVeJrdemcUvicXC76A4ihN92EgMBB8fqCiYGbHaoijRbQ0hWx754DwBg2oybzLa7ZzPRuPFKEpwxF7G0otfIc9hA3aBedr0l8WzhcV8NIVE7cwbHknsLXf3xT9DV77zoH3pMVVQlNdJgwgcyzMD5MVNEqk7TOknBvbnFXBzL4yfdOQMA0OUqjqk7SMLXDzrH7ON3Msnv3dVKj32H0opawaDNqDStfhqtQjiKndxmR/lwW+FU+uzrBpIMH1T8gT6+FyfVSF0Syk3/aiW3jRMyupttf1SVdU7zJSme4CRBbKujk+CMxSSmXzxbh2U0daeG2N9TSY7P/prb7XgV6jLwaz1+w5wtfCYcAdz6r/+IgZyRWdwGb0oNM9tuwmAAQOUiqrXeNpp69uOyuG0Vn/A+5HW7zOwz7DUmkkMoIl1wmyrXM3zivEM6MBj9qXfl1Zk8szuPW7Pg5dSIdwxWKWVLPzS7+A3hs7YqdjQAYFDBMgDAklCmHnk82vE1ah3VSO2hDG9Y3pVpUz3VX6pRKsCRpqsjoYX3IXzTG6YD6vhMABbCsswyy/4SJgBxgsZhdWhYQ8/sPvLzRcvRqNze3dzaNZvnQ3dwsyqbsjKf7voZTQxORB+SnE6HDrIzQhUO1RBt9A2im9jjx0BC58c6kdl3vNIzV1VJvFUdvCY1ltAPqUQadM4NZp/dTh6ny16m7chBJFZtjRyba9l7AABxsnb5e9WQbF1YScJ+YiTHtOEcypn0++htPSEKhdnLuIJXJhCN+SsytullJuP6XfGgPr6bx/uuN7XiJ3zxBABgz2Mk97vceqPZtiGDBPyucvbp51fNefmBqOz7HkSKow5qGR4xiLX/DrYo50c95WBcKmTEvewds+3+ATMAAHGBSkGzmgiljzfTUp5R3vXsWB1eMrKViOSdJiKfUzozLOD5tXwWLuitHQCnP8E0rf7Z/OydfzPNxieYQZottT9HEz2mUFbmqilMlu8WxfvQO4bIrVrV+Ysv1AonJZ8RDTVfy7mM9OMfq38DyeyDQkve+DzL0BC3ShdquoVjSlfJ1PYaOgi22bVzqGsEdwW2LUywL/qCdRyj+jMYev8QrfjaxV9J5Sh07FXKoOLWZDoa8mqITNMC9d/tx3uJsM5O98XQMROwYdPm4wpr6NspWa78z23H1NZ/2k1WWINllln2J5oAYLMQFrJ6ZsuXv1iCgRFcAIzVCNB13TxB5K7Kld57oINoY1MJwxyGhumqIGXPMBm2tZbfNf+NbvtOoOvdFaJlQYx6hiOVhMumVCYP9/ci7/Ktqv82NqjG7LML5F4yw8hvfbmXyOHUEmp+F/Ult5TUlG/2qf2K6UK+0bwOh0oXal1O3s4epkM5Kn9kBZ2oSQo95jNA9fAScmcp/yKf0fTJHLNPy1l3AwACvmQApiHuJ5ycA9dBLZDnqmBSr2MMK+A0+PIafQ3yT8nM5PQ93+zTtZqhAq5YcjXShwjlcD2RSfL+RWbbEiXJ47qR6C7RrWr1FRMVuJMZ+Or54WOzT/0opvwEqdp/LUpixa4Q71d7ddLwFFWLcuUhIoj/LOFxl75yZM3ey+7WqHLJMnKIfoG8Z3ecyzG8q6RvPvDlvfPJ0BzQilimSAVdS3Q28AXyXLkh5OsSAvW6bvy17K4goupZw1SpBYLVmE7yYTWg76GraQ+J5LVJb+4OchVKynQRjdua9TO3TLJfiC/P6a3CC9JUPc2yRj7/zX+7wOyT8TglgJrn/Rej/vkqNuUVHhfC6peZIlc+decxtfU75VoLYVlmmWV/oglhOqFONOvQF5a33YaUEF98cqAaABAXqOvtbT7IVfQ6J/kUr37ki7y+eQYA8CEoXJc5XldVWXgyOZ4zupJj8K/hKprroNxIytpPzbajulNb+FAYZVP8rmVQ486nyF/EqXg7V5jmW3xquRI6VCWc8emUwa38kshoRyI9Xsk+Ogix5iyOyX89EUT9F0QD/ucqTmCLRijl27kaR4ykl615ImVwI9VP9xKmxdjaBPGFqEJDNiXB7IzifHhVqqrLvcebbYVCNkb6iFslmJc9wiDahuvnAADyq3U6UqckIpLKOVxho2bS05rsy3kRbWow5s9kUvCgxjyeRyUWe9KZvpLTwHEnjLnU7BPsVOlUcQyafUJxV3WqOs+8b7VYoddMLtz3v0MUM6w/EXOb9GsAwKsPa1HB0BTyQmPOI8c3rQuv/bwgnudbDznKUZE6GDeykX+coR/w2ctX+OSC/xLprriqi9m20EaPZIuq9uOJ4nWMD+C8uJvJxQ7ZtsDs8/Rhei5P78bzZFbw+XEncKzugHCz7Y+bqwEAZ3xCT3fa7fwpSjg/Wxv5bE96Xnshi+6ndFHAXc9BPv012sOsOCzLLLPsr2FCnLAcVoe+sCqbnPhwe7G5mp6ZpmOq+sdz5XAKIp+wjcpzNY7etZn1XJ1a3ZpzuzCDn72yjZzVZT3IOUUJXlZ1n9PMtmHbuPLEqxp/ZV14vlq1mqaG8FheO78z+2SGKBG1eKKOkuvIWaU/SdQUqApmtK0WnXgp6+J5VH0/vxSuwA02yoEEta0SPZ5xY4VfcGxJ6nyeJiIur55MCTFSdwCgWXLl8+7FNB6HEvtzKaRlbzP+Q4PJF6WrqtlBu4kYyhSyalSCcmOTdRL65lJyM0nXsXJxjeK7jPKB+RFa8mW+Kpjg35OoooeTXrU8EDF0qdoMAJAlWlTOreZ/YyoR8xBfjiE9nPFeu9ukU320nqjoi78RHV/wMqV6hs/kde1bx2u3e2uplcKNRLDp0YyH+mgHebWiWo7p3F5sm9Oqn6OcKiLkQR+TE914zgMAgBWjtUieYSGfsJBEfE96dD2NRIxemfTiiUbyUavu+q/Z5/z50wEAO4YwOTxgJuOvAm8Y/LPj39RID6739UTBlWG8r8HruVuY3FfVtWyze0g4n97ez3KrUdeqJZX+uFkvLMsss+yvYidwHFaHvrBibE24yWcb3AMZ+dv41v3md62q9NG7W7lK3xhOb5pUEdfZflyB6310TIxUQnfJ0eRttlRx1ezfygjxLb5ZZlv3MjIfjarMVpIqoRUSRFLIsX4uAKBmk65YFHwB0dIBFVWe9S8mMMtWIqDnVxDZvXzjY2Yf13ImV9ePoIRL2CEl4Kf4qBtO11Iusy7NBgBk3E+vVMX7XJW3vc5I9NzXuYpeWKXH5LuFaExkcEXf680VN1PFf9nCNS+YEsD5aBJEQE39yAEVldKjOHAtvaru03X0/YAmxkk1RJGHMqpHG87k3iEamRQkhQIAuvsSoSws5e+djVvkTQTdVrQwLIl/CPWqgEX3aHrOZr5H7+S/p+tIeuU4hFKgQV0V+xiR7kFx9Kj5hulIesPuu+VfR/y+5Zs56jo4/qI6XYTi1DjCx7UzeB+6Kg+jiOAc28rzzLarR80CAIzJIRIqGEBvXbgKQQ/04zMx6Ekdx9SsCmyMm09vnlHUxL2Qvx8aqqPuI9RzU67iA+uUV9C9jon92xL5t1MTMdbsM62Zz8eu6no0OdsLYVkclmWWWfZXsHbMJRRCvAZgCoBSKWWP4z3eifkatcwyy/5cs9mO7d/R7Q0Ak9trWB0aONq/Z1e5du4b2OnHrVqnMP0Wb1Au9xClsPhVGcnRk1K5ZShrVVuJVu2OXpTD1IyEYG4XhybS9R5dy6RiV3Rns+2qw9y2DE3g8VzqXe1XzC1QZSQDCZ1tSP0VKiE7wp/bxrRQnifFQ9jvDuS2teQhnWQdfR+3dWI5U3AcXUjO7vAheRr/sd4GYyb/v3EgSeWxH3IbYxDTIoukuzNQb3l8S5ksbOh49z7A4iO2LBK4Uz4tMdt2V/Nx+yim1US08LtdbpL7WV4klRv8o80+/irsYHER58EIYBwUwq3hohL9kE52U/3SlU6tKfkdt8PbejMYNMKP87ahDZG+Yj/v2dQe3LqOjuczUKoStGPa1Nicp+KKv93N+b59DLeAl6owh6lqi3vnjQ+ZfaK6kdAu28n6lQn9GZQbGMbnab7Skp/1udZcv3sin5O0UG5hm5SHwU+lSDW72oRA7GK4QnNv6tTXPMowiehbSTXIdaw6JAZNN/sIp9p+7maa2d9KeL7Hh9LZYWvSgaOGPbiPz+k9WdwS7rJT96xzAH+v8GiHVaSHc7anJQDnnjQaO7ZsOr7A0W6Zcu3bc46praP/lKMGjqqKz1+1B8KytoSWWWbZT+x3eQmPuVR9e9gxvbCEEKEAXgHQA8xOuBTAHgAfAkgFy3WcLaX8uR+4jcmWJjhzd6I2g2hjY7FOs/F3cIIKbVz9pwblAQB+KOEqOsyP6EA6fM0+F/XiKh1cRUT16EaiqLN6MpQgoPnnBKTKikCoZFuDADVSHjKLdGXpM+Iy1QRwhXSt/YhjGMSAUa+DVA81KigDQKU6Z6xCVj9eymTZzOlchJoq9GoaW8dwgz5XEWEZtRjt4bxm6SKqcWzVQYjFC5laEqfq6skBDIQtbeWiOvdSnY5k6JtXqTGFKk361I+Z1uM5l2k+V32g6x4+OrWr+h8dCxuLuHoPjOI1jj+s3emefkxvkkohtWQoQ1CCnERnyR6GFDy5X2vSXzssFQCQEkxk9aPSax+oMpY8q3W5ulGDmbA+PYxzdpGSohndnYgzPojPgl+ErksYEkO0WEZBUzMA0qXc/W61o+jbRpKmRyh/3vUdn6PHu3NM672JhFI++qfZFjMoiWSfz2DVqOFEttLOOTDkeAzECADhvvzM3puhHI+upu5/3v28l6kzLjTbiliiyKsHElGd9gEdSJ8NVM+leiYd/jpJPKeFSK22xQm3px12TAK/h3Q/plL17WXHOqqnACyQUmYB6A1gF4A7AXwrpcwE8K363TLLLPuLmxACwuF9TP86fGxH47CEECEANgNIl20aCyH2ABgtpSwSQsQBWCal7PIrhwEA9OvVQ66d/zGqg+mKb2nDF72nwhlmZSnJlTryFkYQpWzmT2MFA4BvfekuH7GdfFHJKNaei11LCZSlGaebbZ2qCsnJYVzt5+zjeSZncmnvpqr9ykadZlP7A4MQ/S9hQOHWciKt7pHkQwx5G5vQlEHYVnIYRk2+fBuPb3uE6ROBiTr5OSCZaMgrgauq8QBUqpqDm6cSAbVNyBZleQCART68diOPeVQiOY/vC3SazcgopS9uzGUhAy0/81X65h9z9X7tGq1Z3rtZVT1W2uBVIakco4oxqGjUqNioauPXzITlKxYSBb84TSHFXaxQVLv2e7PPTSEMvn09iwSVq5ThGP/2ppv+7m76mThrfjUA4B8nkfNcojjLjXkE8t9+zuPGdNZcpcOHY6osZN+S7Uq3vpXBq8mDiY7vvUyDAgPdT1XJ1j4FDLFwxvBx/mR/gx5TE4Nvi7uQR3a8SGFJeQ05rNAVDCpedbeWERrz9cs83l6m5GzuzOdygJva+obMEAA440jz7KtSAo2K57W3qZcJ6HQrALDvYH3GByo745UbzkTh3u3HxWH175El137y8jG19eo6skM5rGNBWGlgBcjXhRCbhBCvCCECAMRIKYtUm2IAPw+G4WCvFEKsF0KsL6+s/KUmlllm2QlmwmY7pn9HPY4Q7wNYDaCLEOKwEOKyo/X5LTsWDssLQF8AN0gp1wohnsJPtn9SSimE+EWopgi4lwAgMr2bvPL7Jvx3ClePJQcbzXY39DMCRYmAbtvBFJZTe3C1Do8gJ9C9TlcL6fHB3wEA9huZSuFW3IldpbiMK1yox6GE6WpfJ/dz62QmVxf4kgd7u5CcwNkFn5t9bgslGngpl8GfKYlEJnsrlbQI+L6u/vQVs8+BzVw1QzK4sicOZwXrijAiFi9/jRAPLSQvUXWAUrx9PlHS0YqnKCjgedyJmq/wqiDvNTaRx/l0H+er3q0qsLRJzXhhJ9FWiA+FCKOVJO9ZjjwAwM6R5Pp6Vm0w+6zwJ3IbEsS5NIQOP91FdBPmp7mZkxMVd2ULBQA8eoqqQLSQntIPUijXsi8j0+zzyiii660VRJVbwPHfG8zrkuUazXw8ld7NlQ1EdTcMJCJdFc/r2bGTyHHScC2W9/TsOQCA9BFMzTGq2lxz3ywAwPIfme7TP0FXi95ZSlR9ieLy3lE1/z6pI49kJE4DQGsFxxunqi7VR9AT62/jvRIxvL5Bt+tq181ryUHapzDdJvlJBurKS/j7ogYdDD12JeWqjRkr68tUtVgnEeJ133N+rhqqq+PEdiI6vdVhw5eB7bBNa8dcQinlee1yIGXHgrAOAzgspTQkGj8BX2AlaisI9bP0V/pbZpllfzUTtmP719HDOpY4LCHE9wAul1LuEULMBmBk8FZIKR8RQtwJIFxKefuvHgRAr+y+8uvvVqBc8SBGSgcAbKwnB9OvYjUAYHsMkUm8Sp2JqKGMcO3XWqI3eOoMAIA7iJ6hlaXkqQrquBqNTdOeoOgD5FOeqCXfcUtvJYWykZ4adwU5NN9ew8w+rkRWTK72cNWKrCS/cyiYxwh4i9xW6PAxZp/qH5gCtPN9ch2DFxM9HbyT/Fr61VeabT0N9MCVf0cOwu6rZE4G0vNUv5VeyKBzdZxXuT0UAJBTxWt8fS0To5+fSsRS6dQr43NriFpSIzi3Ww5VAwBmjSCySqvXYn+GGRxK/UtMlQq4kvLMXrVEk61BGu0ZT44hsDemjHPs6Ut0UdbMFg6bplSeX8sx/aMzkUJxKHmiGBU7J310crhHJWsbntBqJ/9ACuqI0CMUhzb10eVmn5nKy2nEZkWoYhHSqKHoxefp44d1tWUj/iqqhc9A2SuUSm66ihLbSXaN+uYV8DhTilT8WzbTwpxLKSe0bRDvs1E1HNDiim7FO3lVk7/78QI+C4MU6lcDBADkBXBnYVTENqpGG4nwthSdwmRU/W4JTcLI4cOwcePG4+OwenaTP37x1tEbArBnDDghBfxuAPCuEMIbwAEAM0F09pHakx4EcPb/ZoiWWWZZh5rQoSonmh3TqKSUmwH80lt0XLuOxjLLLDsBTOiM8xPMOvQ16mipRczexXi3iduO1b6awL0si0GOnhC+FzN9CNN99iwDAHR7jaTmj731kBfUcss3fAEh9YipdEAUvcltTNQtD5ttW3YxGPe2UalsAwbbnbqUpPsrV08HAPQM0Fn8tlq66Quuo2a4ZyCp0KRzZwAAWpU73RasXcwhQxgEGruLCqD2Wm4z0q9nZZ2nB19ltr32U+6gI66bDQBYNpBpJKOyswEAwUNGAwAqHW22tnXcEkQ38bhx4xigelj5Lx7+dq/Z9ompDAeYv4/e2X9M4Dbjs110kZ+zbS4A4Er7NLPPuz0WAwC2T7kLAOAo5oGXHeA2/s7UrWbbQ6FMZwrx4X20x3OraS/h1jnHo8lww+6WdEYsd9EJMvIwqVEZQUWJUh+tNlHZmcR5lxZuye74hiEQj57C6/rnYjo4hg9INPtU1HMrNulqVqJZ/MobAIA+00le9+zEe/XqmoNmn5tHcTu9qJBb8nP69AIAxNTxOpyxWv99ahXDVuDLratQwb3wKM37d6gQ6pn1iNlHqD/+rZVs8+4GPuuTXmQAafX8x822oROmAwCCw7n9Lb2ejp+Ya/lsu/txTi75SDufrhrOeR+kH5PjN0utwTLLLPsrmAQg/wRC/VisY19Y3r4Qyd1xWwVRQkmiVq/ceDqJ2gFvMOXBDiKIFYFEXOsfISLybdEqjRM9atWPOhcAcP0jJIqjsomERKsm9T1Otj3kR7dzYjOJz7WzSF5KB78XDdW6Tw6TbNfdxdSoy+K50jsj6W53eCulTpdW1LTHpgIAkk4aAQBwBxMx2Mp5zTfu1GETLau4Wpd5SIpnX8U+tmyqiTb5EQ0s2Vth9ukVwzSUzSodI1Uhip1lvNaXhmrS/YBybpzZiWhA2kgYXx7DwMtDnRid8oK37lP8GK916CyGcPxrA4NWbx3GeXNKTbq31JNU7xzBEAvPbhLz+5NGAwDyDlcDALLuvNjs43iZhPYwhQY+O0i0dHoVkWFUm9SryN3LAACthayE8/JkooxFhQwtmNqTY/n3/N1mn65JDFe4aLAKn1hDxPvqZdT3yj6JGmcjL9M687GqKo6RRI/uMwAABY1ERJ4mnfwc1X86AMAOfiY302lzeCxRePpYhn94pO7zSR4RVdd/Uhl09klExa5xSv8/RSPR3DA6elIP0uHg/TzTwTxrqOFuU8/am1N0ClaTD58f4W6FwNGdaEc1If4UD+CxmIWwLLPMsp+YML2VJ5p16Kjcdm/UBSUiUK2ihssWAAa+PgcAUBBIPmHNYa7s//lyMwBgxXgiCGcvLa2To5RAbxjGVTViPNMiKv5JnuizdH38mGx+Nn0xFT89J/H3FgeRijcUwvLowMuWftMBAJcXk7cpDCAai89nuIEzlxIljjTtYnYeIlLw6c2qy60r6O6+6VTyFP/5TIcotFRW83iS19oSFcoxtChkqBDWF5t1/cYnc4mO7jyLK3FXlSY0xEG+7ZMKHYQ4MZy399ZFRCjn9OGq3G8beSTHSCLRkgadbpNx42yOoYlju6czOb27vmXYQWmt5vheiuP1u6sYglenqv0s3a5SgVTITNT7urK0O4cqsfVfM0Dy9FOJvvZ6U91zX6kOJh7Wn8G9YQUMbPW4eb97vk1kUnQVucu+GbrqzM0qZONsVfGmoYxhFJe/Tg4zdfipAIA1H2qkG3wRQyHGOHk9DW4ifz8Hn5+wGs13FYJoKMaL81DQmQnNaXsZpOxS4THCRyPFs7vzWdj3AgODV1YyoHfsUgYce/ccarY16jO6CjjfBx8iIr1lONO03uqnZHhqD5h9ygL4DEcHeMOD9iHLrS2hZZZZ9texE/SF1aECfn3T4+WK+6+Cr1ENJlMHaVa2cBwx1QxmLA8ntxHepAIWVeVkxxgd6W8kgM7bz8DF00PJHxhwdrVTpzcaImydXqTcS+g/ydVsVyv6EDs9UEbVEwCoSSR/5qOQoPyMgYRQGui2b55T59McUNmPTJz1UkGgkSO4utpUupCtjRSKrKP3zqYq6RhIxUjwbj2gEFyyTu69fDc5sYndeG1GRePPLibiqnHpB+31jURmF2eT63Go6zCE6YyAz7GBWhXooKrpmOQgCtjXzLF02kIOxQh2BYCKMVfzOtQjFGNnny8OEgmdqpKJD9ToIMrvDvCaT/+Ocxl+M3/ureH96WrXfF3rMp7TCMacu4Po5Z9+REuHekwHACTbNVc59QOiyVUffQEAcKr7ufVr6u5f/hbR8QsX9jH7vLtJzVNfIlAjqfuwkudJ+lJ7/GrOJNIxqjeFvMX0sPpL6JlO2qMCkZU3DwC+60zENmkB0f1epRW/p5zP3in1a8y2RvEHWzjvr3SQnzKedZeqNZk3aIbZJ32z4rcGTMGQcSdhw+Ytxyfgl91Lrlk075jaeseknZCBo5ZZZtn/JTtBEVbHclghsWiYehvkXK6qbzbopNhrYomO9vgr0bT5TwIAZBJ/9xlK7sEVqOVZRCtXKJva9zdE8Hg+Nq5+vaWedG/BFbz676xec6CKHIQh/Zv/IOVBqm55zuyTqMTQto1jfOzwD5/ldTQwjunbvzFNaNxavRoldGIMT/MWyuHu/u97AIDusylDUvDKM2bb+CtVDcMqosgb8+jZmtiVq2tkb67E20o0gkgMJ4q5Ro3zm9dYnWVNMa/nlVV5ZtsRqnxNnZKVXpZHdJOrVvaHOhFZ5Xn3MvskqzSUchWnlrmL1WHejyR3eH6oTpSO+J6cYdFQetzsDURAY9LoRfXaS/kX71dfM/tceS/Riqc3nwHbFnI/7mSmuOyz6Zi2VJVGc9uHmwEAS66np69RpvI6Cjkvdf7+Zp83L8gGADyRTF5zaBqPd/6zTPkqyiGndUGVluGR6j7fpWL0PtnJ+zt1De+VPUDzUUnVVAZsilP3+UrG+sUtZsJ37QTKCIWWa45p0g+Umil6lcfLuJV9s3zJjbmbNEJfHEQ0lqSqREUH8E801MbntGwNPdepLqfZ524v8mgP+4W0X9Ky9cKyzDLL/hImBGA/MV8NHcph+UZ3kklnPYbbLiZ/cEndUvO7mgFMRVyaWw0AGKZWSMOTGOjgG//jnVrIzPCoGPzU2DRyJuF+XGUMgT1AF6+IfIseptKLyDkEPqZWxM6MtA7sPcDs846DsUiXhBMBrRL0YGZ+TMncoGQiIa/JV+gxHWYEcst2ruivX83VtUbViytrM6ZHv6Uszv7XlKSIimZu2bMZAHBXIIXesuKCzT7vLqX3yEfJvAzuQsTZPY7J3Nmxum3Gaoqw5Qzh+IJ8OIfvbub13NaXc9z40Ryzj/dFTOjeXcF4n94ecmSeIF7rJV8eMtu+eCYzFuzz6MnyGcaIeY8vxyKVCCA82gspnE1HHC//FsYmpf2DyEvatTyKXSVcN69nNWvfAURhJWH06q1T8VgOu0YDI5N5/WP+TXS35QvObfoIlUBdxPFX52lZ6NJlvP7ZSyhwGBdKz6shZyOaNW/nVZkHAHCH8LsabwaUheyk6KLpJR5yqtnn1QIer1h5WK9Yy/NF3MBn0KgKDujn3SjKErzidR53LJ8Nx7I3ODchGokWdmWGRLivF0aNGIZNx5n83K9PtlytRCSPZj5hMRaHZZlllv3JZm0JLbPMsr+KWRwWgPTYILx71xj0amHogqtBE4QfbGfg40zlgverIXTfI7h12FDDLcrBNmSpkS7icPO7x3/kFmK7Cjp9u6+G8gvsDO70L6bbvKtSd95/B8uF+wdyayx2aW2l6VkkrT1KXyvsb6wKE/kwiVZPAZNvxQFd5UiqqifbXmWAZOc4ktehKdx+NZRqbaWbxnB7em5fhipkKbXKw6kk+bvlkiRftltrI+ZuVtrzbm4tNy9gm6WvkcBvm2Q/vzPrA772BcMj3r0om3OxkSEctwzlNnimTSc/f3qQJdHrvJnwKwOVbpja5k3opkNFcpTjIukUnrtMbWPyqvn5iEZuJ+sjtdS/7yaS7Ls6c8vk+w8S8qJVBWdW7NNjsZGcPqM/FTV3+NIB00Wpew5N4vYvrGq/2WdBHu9jn67cKj93KQN2n/ue4Q4XDmBIzXXP6ITp3RV8pt56+WsAwIEPGdxbrFKbEgt1orE7jtcity8DAFR/TIdL2O1Meq7LmsjrKtls9rlgH5+FlQMYBhLhw3ShnXV8/rtG6JsmVOpNRRNfGL5j6NBYc5jP8vhupCmMLSkAxHv4vNe6w9AuDM8JnJpzYo7KMsss+3NNiGP7d0yHEpOFEHuEEPuV2Ocftg5FWE0uN7YU16LLQRKi8qTrzO+uaeYqIaq50lYGcvVP/44BnqmTuDoV1+nUkD2KGDaq1tyZQfSyLoMopzZCu6MnbKB7fsU1cwAACf5citK82dfWxBWspfsEs0/QLpK91SsUWnqGbnxRoiRcOjMRe02tPk/C40yCTZ3AQM7oMy7gec+ZBQAY8qgm6J030hU+5FumrpS9yErQnc9iusoLxZTYmfv0C2afyCy6ve+9hdVf1qtQhZoWooE532m08d17DJ784d07VRuisqUsJwiXSnW5XNUKBABXPMn8vl4qYHEd9chtvUh4n99Va6HbG4hWpYttw0o5L4mq/mF9GNGID7QL3lVBZOurglcNvtxzmKi7cK4OETnzShLaTevpnMlKIuquWsXnp2UmVUU3NmtJmjA/PtLVjTzn8GkM+/jsXaJio5J1WpYOj/liB9F9j7FEX94r3wUAxKk6AG3NuZTf+fbnfIT+i21EpUreriAa2+DX1ezTtw/neUA8UeoyEDGO8eEzl1sbarb18VKViNRf5srDdCyMK+WzuLMTb16SEcQMYPMYItzhjWtgb9UI/o+baDcBPyGEHcBzACaAcuvrhBDzpJQ7/8jxLIRlmWWW/dzaT9N9IID9UsoDUspWAB8AmHaUPr9qHYqwgn28MDEjHI44ooOiJu3ij2uuPqKtsRc30nhkKbmb8ek62DR2F3W1pUpYzs2iRE2scg2/sbnIbHvJdqbMjO7KRFPPFlassXVTScqL3gRwZBpMY1/Oq9d6BoF+fNCQayF6cn5BKZzB3Qfqcd9N9/zHXRnMN12FPvS4mGlIH533hNl2lUqC3Z7E7wIV6rj4Rq6e90aSE/rv/XpeyndT8O6hZ8l/NFcRHaxazRCDMSO0VIlfmOLGfHme6xdzPh6YzPEWVhOFdI7UgZdv7WEw6UXd+GhsSeeKHi2JvJLKtECg6+AuAEDlKoZwRCthQ8N8XUqOx5DhAeDXj+gi+EUin4ZiIsS8f5LLShqlw1Z2+BOldBnD67DXlRxxfDVdeOmHPPOziT04302qetCuRUyHmXAv3fTP3sz7fWYb0b/le1SF6rNZMUgEHVk+z0idAgB7EFGfu4T8XJhKnTHSrK7vxfCDOYv/Yfbx9KLm/44yBuyOLiFaygvj8xq/QD8TjjM5L/kN/AP4ZBP5xs7j2DbiJQYg1zRoLnfEOO5KdkX2R7OXvpd/1KQQkMeuOHq0UvUJAA61+f0wgEH4g2Z5CS2zzLIjTeL3kPcdWqq+QwNHO/fIls99tghDE7mXP1Ctk2KbXFwRe0YxiO71zVxNDU9d1H6uSkalYABoHUWvXZXiZvYpb88YHyIJ0UZYryScXkKj2LRRheRgKD9vdvGL5OU6Ncc9ZRYAwLeZqKPhE6ZW5H7D9JRu7zAR1eByAACF5GIK3qeszN559NANf4hJ217KEwgASy4kB7O2mCkmI1Wy8OgPueKGXs2KO3G9tPxI3g9HJqXGZdOjGKTq471503Dzu+d+oGdsl0o4fvsKIisvhUAX7ue4Z8pNZh+RRpSxtZVIImsV+TOvifRWCXcbPmo5gzILR7D6S3otaYnmbURc3n2JpmrDNSoOqs0/YvyikvfTQDEeX82RGdWQGt4j4gzsSeG7lhzOqVEJx7drX7OPpzdTiG7+ivdhtUoA76o4qz3qmrO7RZt9Hj6JXFvQYqZeeUWpgFFDBjlJ81G2evZ3xdOLKprIvVa+znu27ywiqz6xGpW9tIFjuMGX4zYq3zQeJDIq35pjts24l0HJrr0ELQd6MHg4w5d/K3U2IqgPtmvP8cxDvA+5I6/FOZNHY8eWTccVONq3b1+54oeVx9Q2KMD/NwNHhRBDAMyWUk5Sv98FAFLKf/2RsVkIyzLLLDvCJPTC3g62DkCmECINQAGAcwGc/0cP1qEvLI+UqG91w0vVaYv/TMt2BJ9O79m+GnIQl0uuMMUerpifOri6ntFf8wtVKu7HV7maes0jYjlcSkSUcOtss+3ucqKvoTkUbnMOoThcUh0r+DaHpwIAfIZNN/u8tJUo7+zuXJ2Dz6BXs9dgIomWb4g+3B4th9tUzCRumzendtg/6EXa+ORcAMA7K3UV4c6qSm+PYHoDcw/RI5Ty3+cBAKULmJYx6rHv8VPzUzI1/iHkh165njyYgaoAYPs+jsXbh2NJFtWcixaimDdUKsolN401+1S72DbCS12TKkbwfg69s+e3qSvhncV7kl/D79JUsnL1DvJcu3tcCAC48Mq3zT4HbyfCNCR0KhYSMdpVEnHhlWeZbTNe+xQAEHwKj1PyOhGuTygReuho8oSeJu0ZM/7OrhySiraWHs152rCeiO6ywfpCXt3Az2adQg+v1yFK0Hw1isix53m9zbZJF9Lre3Mw08uGbSS/Of0GosB+C/lMOKo0F9o9WtVGrCBKskeQkwsYT77L1aqfH9nAsex/nQUqkl+i/HeDh3Prt4BzcPVALWTprOB8pIV4m1JIx2vttfOSUrqEENcDWAjADuA1KeWOP3o8C2FZZpllR5gE4GlHpkhKOR/A/PY4lvXCsswyy35mHcds/z7r0BdWiDdwcoINz22tBgBcfPFs87spb28GAPzjI8JkfE5Cu6yBJO+0Am4dDjy/2OzT6eZZAABPOF3UuTmE0ynncbtnEMcA8PQykrAjVTUbqYhyVzi3KIYG0rndU80+l/uTUHUq/7ktl1vBrf9gukfP5xjWUB2UZPYJ3sgtp9xEYr5lChVOS2e9/7P52Ksq3hg/DTtNKUe8v51j2tuGADVUB/xDuI2sr6Zjoa7VhZ/aTVNJDJ/VwBCON3MZUDsjgU6JyQN5Hu/iXWafF3M5ZzOV+qaP2noM8gkFAIi8ZfoE0dxWjaynAyMvlFsfQ3tgZCPJ/DUZa80ub46lztnMTZyPsIsZ9GhTZPyhVh3qIhbTO35gAbfEOQu5hR33HontjbeTUkgY2snsUzGHChXzLuN53Aoq3JzB5yj0Im7lBjk0ad1tEK/DsZVBss5qzvsp3yr9szLt6Cn9isG4TxUxmLhF1aT03sHnsnEC1VG9mivNPgMM1Yoybv0Mp4FvBp0FrQ7tADBkXTo/zeuwl/KZcwczZc3ei04V47kFAK++DGLdXd2KlvYgn2T7Iqz2NAthWWaZZT+zjowe+D3WoWEN/fr2lSu/Xw6vSqWx5KNdv2UOhi9sKqKLv16ttNO60NX/WRJXo4S1moAeFsjUBptCS+5QIoZ3cohYhqeEmm2TAxlo6Ti0GQBQE8+V9pk1jGm7O5QIDPGaLJV+7N/gzZCB4nqimHQ/rtZyNUlhe6/RZp/99zDwz/0wieYuxUQ39w0iYW8EhwLAoaafoyIACFDE6e2PMEH41piLzO8Sw+nWnruQScJhMZzDjGSOdf9Brc9+hqogc1Fvrs4LlEs/OYQYqH88iWi/nRq1zi5nCMJ9Q7nqS2+er+ktRq+WnXaX2TajippSnlAe37mK6MM+hiS5qR0VrGsZGnr7NW9S4TW4D4l752G69qVbE9ABw6jztP466qg3qcT3HhcTZSyYzbCPyDCtJ9XzEsYkRl168xHj/6GKiNSpHCSGbhYA7Dyb+uupk/hMhIxhsKxsJXp9162rIg14mpWBIp+hjnr4/mVs6+QzJxx0pBiVxgFdEzNgFO9nbiDDKOICSaTPTdZhGUN3/wgASMxlOpI9jPfBGcX7cqiFfZL3LjD7vK5022Z28m4XTffeffrKBUt/7uj5JYsPC7T0sCyzzLI/16wtIQAPgFZ4wbuF7vvW9VrVMDabkhv941ktJ7KeKKzaGQoAOGse1TltPjp1w+1N9LXbTR6hWqWajE8ncohzFpttm6SS40hgWETQLnIQd/dSYRKHicBc4drd7V3CdCC/GIYBZJawuklOLJOeUwczZKHo8TvMPq+/Qz5n9vQ32HYeV8p6pYpqhGIAQIwPz1nSRoUUABoUD1G8lqjvX1118vMLQ24FoDmse07j+ANV6MKh7lr+5el55KZuDqW++LndGPpga+b8P6uCKi/qPc7s809/rvAbVXhJHzuDG/3PngUA2HpY68unhxClNC9gWpPvJCJBo+px81pKyRhufJ6c1xw+jaE4NQvpvjeCQou+1s6k5kqimNcWaX10AHhIFZI25jItXiP1dc+y5uL4DN5vx3g27vQm71HJRl6PvGKK2ScoMRQAEDyI/OaeRxkEeng156d3T50o3fkehj68n05QccEGava7/cn9LR1J/nTUWv1sO1X6jltxZDuayLkmKRXdczZ8oK9ZVewRSqbI7eB9LnQSuSV7MYTDK1ZzWFeoKumHn3wJzhLNt/1Rk/LE3RJaCMsyyyz7mXmO3uRPsQ7lsHpm95GfL1puarEb9d8AwLecHqAtgqtPwOyZAIDOd1EaZfx8oqcvY34w+3ycwSC+C+LJNbSupIfOa+LlAI7Uyv6nCpK8eyxXroMq2LGqiccdE87fDR1xAPDU0tNTu5JpQcFn0gPk3roMAHDoC66iCeOHmH1c1exTfMrfAADpJRTEy3mGKT8HV+gqwktyyDfVuo58PM7sRj6vQaUadT4pw/wu+TmijjLFf32wlatrdCBX4gEJOrXl+ZUMIr17HL1oD3/LORjTmYghTOnCjypfYfYRKURsMpfVro3Ecmf/6QAArxU6CNQI/qzfSS7r5e4MtJySRd6lUwjvr1FzEgD2jqdHK/NUivM5G3jvwrsS2fpMv95su3wIuaTAGCKUt1a0zaHVUiNtZ++cbCLDVXvI1816nV7n1mrynf+6nvPXds4vGEw09u4aopMn3rtcjY3z31CgUX11DlFXp8v57Nm6kDOr+YD3N6i3qnfYpnpN6ZJvAQCLp1Ivf3AS79G+bKZcdd+62mxrSABFB6gKz55qAIBb1SX0LqbX0BWqk7c/yeMzfGbNMgy96j5s2HPguDisXtl95Zffrjh6QwCpkUEWh2WZZZb9ecbA0RNzS9ixXsJePeTa+R/Do/b7/9lSZ353azDTOe44zL35XWNY2y7sIHkjVwZ5I9vmb8w+nj6U3Khu4WpprE5GVd4uXtpjVmjnCmXK99qIdJpjGKvkW0RE4YzXNfoO1nLlSlzG1bOlshoAEDKW3h53BFFB5auPmn3Crp7NvncSjSVPo2Tu4flEaQVrNMKSapwFBxnv9X2FlgwBgEhvrtL3fqk9czYV9yObFZeRwsRcZyyvw16pj2/Ms1cV+cDmWKKnJoUugpuJHAra1AKMtzNt6scqnntwFWOo3F3ombPvW6XH36IEFINC+bvyFhrVo1sVc5u68mWzj30cE9YNLaWWz+ZwDCso/xOaqWPaIq7kdb/aiRzbFoWKpyaSO/vysJbAPppdOpHPU6+/kWebNeGf5nfG8eqalSSy8kz7hRFBfr5IpzuVK+/13fcwnSlqED189qFMUt5+2Qye5yF9z4xKz/J2orJOT1EIUvqQa61v4yw27snuG+mNfO8ixvzd10o+cFM2ObkYhcAAILWZ93zn7XfgvEUrsaOy5rgQVs/svvLzxcuP3hBAZnSwhbAss8yyP9dOUIDVsQirV3ZfOe/b5Uiqofdtp6+OeTL4LK83uc+3XUqvoJ8XFwuvnUQopemjzD7F9URAvexclQ7Y6Y1Ks1UDAPa6NJ/TtYWeJuHiKl3xJbmMoCsZX9Sq3t1+e5eZfURUKgBAqqTe2k9YNbr6HI7xoIoy7xOnvVRBVVyNnZFc0W1rGatVvpycQECC9jitepBxRGljiNSeeoMo78Jh5CfqVGXjEfdrqV6f8VylGwOJYgwJXUPo7W9jdNT3thJ+Z8gnX+JhUq/sSo/svkZec9tHwEClxXbyaP4Ozn+Q5LV+W6ThQD9VYCPMqbi4dxldHjqeHji38si6Fr5i9rGfQuTgVcUkcFnM+Ct3FSPPm/M1mtn1LvnKHUpqaL2a76Hh5CYNAcRfMiOWza6E6H7KExqICwD8I3m8Z99jBLqRjD5QcVtNbQqfDP434+lEj9Ec/04l992P1yycHOOyEn2+sUFE0J79zH54pIWIa2gKEfCoSN3WKPbhVUa+0RnNvxGbqo3Y9CmzK2rzNNcafQ93AI6i7Rg07WKs37bruBBWj+w+8tNFx4awsmJCOhRhHbNEshDCLoTYJIT4Sv2eJoRYq4TlPxRCeB/tGJZZZtlfwKQR2nD0fx1tv0fT/SYAu9r8/iiAJ6WUnQBUAbisPQdmmWWW/Xnmkcf2r6PtmLaEQohEAG8CeAjALQCmAigDEKv0bo5QFfw169ent1z13SK4lzHY7oPEM8zvUlV58J1l3AYFKsL5whhua6Sd2zKj1DkAPJ3PLcm1TQzOhEq7sA0kKb6kVCNjY/sSWcntaG0UyWqXmvVgT+PPjo99DKL0ZDNFxEjr8QRxW2dr4lbImaPLnjfmMGUmeKgKxgzntqLiQyby7v1Up2wU7Gf/ZeU8900zSPi/8jaPd+Gp3A50Pme02cdnCLcerp10hRtBmbkpbBMfqMlY8QUDIKsnzwIA1CvdpZRAVSlIpTSJQ1qeSERyO7rNzm1qVgS3R3k13H6n++j5kRsY5Gmkj9hCuY3MDeLcGgqk33r09musg6EJW29luk33W7jONe/jNXsF6228oa8/ZwyDZXtEc+v9RW41jmZPfHQNAOD1y6kVv12ViTdCGOZv0FsqP6Wndu0jTCwPm0wCveY7Jtx7XzJbj2kNk/J3PP0OACD+DYbSGM6c/nVM+JYR2nlQ8TY1rOzXMFk7vIzBxY0/cP6aT7vdbBtWTeqi/H0+L3nn0DmQHcX7ami9Z9TvMfvIBm4XPbGZGDJhCjZs3npcW8LuvfvIDxYsO6a2veJDT8gt4RwAt0OHvEQAqJZSGoTGYVBs/mcmhLhSCLFeCLG+rLzyl5pYZpllJ5idqFvCo3oJhRBTAJRKKTcIIUb/3hOoChovAUB2cqysf/dxVJz9dwDAZId+X/q8y5Vk9GSirqYNRE3PtZwDALisD13m8mOtUprWj7UKr8pnsN6DSps70JvHHV/+ldl2fyjBX1MwV+04VdGl8cP/sMG5t6kL1mOyqQopuXV0ZcetYmpFTS5X5/gLGNzqSNGa3wFKyVTuJhnbsJBo8om7WHvwoUM6ZWPPrTcBAMb0IVG+8XkSnQbp++LnXEUz2qSmXPUM0dj2N5bxu6kqKfxa1lNsbYPTi8cwjSTDxYUi2sW+tnxFcKcMAAAcTNAyPAY37VFJyLZ1cwEAaYpUrnXrCjh1XzNpOuk2OiEMtJ5WR+ag5lsmQ4867Sp9/J38rsczrGaDQoazGLrsbaVc9j9Psr5ABcnmKGQVr2oLFjb/cvI4ANx69n+P+H2QClHInK4I74NLze++Vgn3LdVE855aIs+gaUR/7jbBsrY+DHwNeVnVI3yFSDHtCiqmyjI+V/kOnfBtv5zfJeTQ8eJO4fNqO4tB0d5t7plQarzlW3nPMwMofe6lErINrCpdWlv/cCIDlxPrDwCeI9O8/oidyHFYxxLWMAzAqUKIkwH4AggG8BSAUCGEl0JZiaBes2WWWfZXNwm4PUdv9mfYUV9YUsq7ANwFAAph3SalvEAI8TGAM8HCiJcA+OKoJwsJQ9jkMxAQxP34+gm6yvLDF1ATe67SVi8bzxSNq21ccdxKzM179Olmn8nRoQCA/BryKnENDKBz+fIYa+O1VvmAYF5qhUoT2VRNjqyPQlYGn9O6/COzj/tUcictNZQOqZnGBNoWBUPq5jFg1P80XcG64R0iQIc/V3Tf87kCX6fEBVuX6kTXqgPVAICEkUw9ichkwOIXClFddRoRY0BMkNnHcS6P1/8Urv5yN7msZrVK+2/Ut6FzMhPJjRCLkv8QCXkHkQuKvJShEQv2acrD4APzs88GAHwZxjCS4i3Uh7+ol06ujuzFlCHp4LW2BPI7gysLOzuVY/PWUi4BSZRJaVjECsr+43ie+m+IRA8t3WK2Ld1GJHj+eMrkbP6RaTH5jRpdAMBZbZKTjWDPpFGqEo6qC/ncjQxjKfiBCG9Tla6o9PfZDO59YDbR76WrGFLQ80bqyx/8bKHZNjONUjOp3uQfPeerMIc8iiweUFxi0po3zT4+XUnxrA6lDMyA3Zxjg22s63aS2dYdzZqXnecQIRbaiH79V/F4VcNn8Drb7E7i1rOq+d6sqWhpB2d9RyEsIcRZAGYD6ApgoJRy/W/3OL7Kz3cAuEUIsR/ktF49jmNZZpllJ4xJuOWx/TtO2w7gdADHlriI3xnpLqVcBmCZ+v8BsAz1MVuZy4EXymJx4ffc0z9+yePmd/MGc+/frOrSBb58LwDgx6lMcRiSSp7I3UYaVnzPVfqabPIK5a9ThqXqElbPGVT4nR67QgrednIw/VTKiXMDPWQ/9pkBABh48jVmH+U8Qla+Ok4GJVA+PExEMngTPYLeOXebfSr3kN/q+fQcAMD6U5k+FJZO9FS6frfZNjyTq2fZZh7HWNE7r2IAZlCiSq3x1avmyv4j1PFCAQC9/0sPVOvL9wAAAiaearb9oIrI4+wycmMJV1PUruZLerhcIfSTXJet0Ya9mnyIIc6XbiO63JZM3iWwYJPZtvx0cjBNL/P6Q3oQfYT3o6zywdlEr+m3/s3sI5uJmKsV4nz35jMBAANH0KvW844rzbaBn84FAJRuI7LaWK3H2dY+3qaTk43k54PfcZ6je1YDAM66JBsAsOIDeugGp2hv5Pr/Eh3ddedoAED8Dbwe6Utk2LlLH7NtwVvk1SIH8HhiDFN9mr58HQAQdh4lfOyD9X1wKW9znh89sANVDUaZwGe6vo0sdLKNHj8jCd83gmlThjBghOBuwmXTXKLoxed/5f7qI471R01KwNmOdb5+/TxyFwCIY68ybaXmWGaZZUfa79wSHq1UfbtaByc/d5drv/4ItaHkJIJ2LzG/25VABNRVqviYUqZoFCQz6Taplt6kPX469cRf7eNfUDLHlw/gCpaoOLINxY1m2wEhStZYxXN5VZAneq2cMUQz49m2RXFoAFDcQC/Ud7n0sp239w0AgCOe49+eSWndkMc0KkubRd6r+G0m/HrNUukqksf3rPzEbLvmXh4v6yxyHAe/I9rreZlCjFvJpeR9q2Nukobx3PEnkZ+bNelBADpdZfQ1Wuqm+cY5AIDWm1l12v4ECz9kllHypjRRyQk36lqJBqqo9w4FAASpuo3G56JZJxy3fMfjGRIx+UuIvtKn8Lg+p7DWpL1MezlrEnmtvotYe/G9y4lYkiLJ49m9NUvxyc5ytDUjGbz8N1DERBWrZcRdnTI+FQDQ/SamNBmVtw1pHABY50Ok03OdTtIGAMcY9il5erb5WcgdRLR+dUSIUonzGfO1fgAR8MhNWgZJtPLe22spBdQSQU7xYC3Ra2KQRtDeUtUuVEnm7qzRHHc557BlDT3fS7tfYvYZnUq0+Pnuctx34SnI3Xl8cVhdembL/36++OgNAYzLjD5a5eclAGJ/4at7pJRfqDbLQG78qByWhbAss8yyI4wIq52OJeX49jkSzXphWWaZZUea1OXRTjTr4Ko5feTKFctQ3ELY/8VuTZZeH8v/r76EW6qeC+hi3lXO7UbnCEL4gA2f6QP2oTu4TvC7QDvd6UZVnrZBoM3LGK7QMJVEcKiHwYKNDoYMNCl98BVKmwoATssg3McmBoza07MBACWvqm1eN7r1l3S72OxzUjS3nrZGur0LA9kmroXE8Z6/3Wy2LVYqBCGKADbCHAwLTuTYag7qbdio56h28O9pDJ+46gGS+nX5PNbWD3Wa0ICruD2syeE2O2UikfveT0gyh3Xidrhqv67R1/tZpvO0bl4GAPDJYp+CyN4AgGhf/bwYigvuQKbk7Gvi1ibTn1tp2wGSzaKN+uaeJ6g2EJ6ltfMB4J2Heb9zGo4MWQB+WVm0rYW1cfHfOJvPROkmqkB0vZVBq0svovrH6HUMUdh/40yzj3cQ73Pq3VTuOPwfbrNjH1Tb+hodYujxoyOkwsPg3qj9dMi4u6tULA+vfV2pvo5hHm7tm7dwm2g7maEQxY1sO39vhdn29K50lIS71XO4j84hV1Ee+yo13V0XnWn26fbqWwCA1ZV2XDV9PPZs23xcW8LMHr3l058sOnpDACd3jf3DqTlCiNMAPAMgCkA1gM1HS++zEJZllll2hEkAzg5AWFLKzwF8/nv6dCzC6pYp17z7NPbFUcs6q16LP1QtoG7U/KFMJymuI2l6XflcAID3QK6cu+xayzppPoNNAycw+LAilIR8KIjKDKVNAPD4EcWIVrqFD/mRfDWCHBODScYHNGq0IVWfWknkENpEFGPU3/s8lWEIZ7s2mn0MMndvDInnsNfoIq+6lKEcqatfM9vOu5IreNfRHItPMPvGDCQJXL6VKCHtLq2O6d5LwnzNnQwsHPgPoruvZpIMHnm7Dsbd9rquGA0ADqVSeUAlXV+4kPPnKtbzVLOTBH/4MJLHRnJ1zbKvAeh0FQBAAUMHWvdTx8uoULP6FKZT/aAqV9/89tVmF0Mjfs+71Dkv30108dkejTKOZuf25ZjKDhF5+vvodXfyIlZrdqowjKL76BDxCSNabali+k1EjzSzT95C6lTFD+G8G2EmroeYkuNl04AlbTuf011ZTM3pqpLDbU1ERC/t5vOVFKJJ/RBfzvsI8H42b1x2xPV4D9N6ZzevZv8HJjHAturvRFTybmqxvaAUayOUhj8AXNaPAcBBNheGjRyNDRs3HRfC6tS9t3zswwVHbwjg9J7xluKoZZZZ9ufZXz2XsN2s1uaPxX590VVVP975jwfM77LuJrd0diL5BOlgoCUkOQiXqnXXrXSv2UcqZLXbO5UfKE5gXRX5g96xmWZbQ+c9pZae03jFu6xs4Fi6VvBzd5LWdDeQVYiTq6fMZdrI/kGXAgAmBXL63PYxZp96N4/n90+Ou1EhoU45DOFwulrNtiNvYihH5DVMBt9xBXmVih0M6ajOVRWtQ7RX+L0zidQ6dWFAobOU3FieSlcZ2ybI1FDSbFXKrHv2EVmdc4iIcOUohkb0uHiYnqc6BvB6lGa8TSXZ+l/MQN6cG3UV6kpVSXrA4wwMvSGaSqaGTM45g8lTLZ31ltmn3/W85i7ncc6WXf46fq99sJHhAQbSGv7a/eZ3nvpqAMB33RkOM/6D2QCAL05lYO1pi+cAADbdpXX4s85h28Yy9k0+mfPhtZcJ6yU9p5ttvbowVrrbfoYXlL/KIO2oCUzvmZDBn8nr39V9ohmgW5jB+Y4bxGe88VvyqotrdRBreCCf86BqIqmgW/ls1H3G+37/xUyvclTkmX1e2M5dwajUcDQff9woAKAD4kb/kFkIyzLLLDvCLISlLNgBjIsB7Kqq8z4VyAgA36oE5gSlM55Vzmo564PIRfTzVVpaNj1kTxDTMDopUFHhpDdqfSNRTAx0leIrFtHT8+L0I7fbAxN4vBaQV8OXc8zvwntxpZWBRDPuLK7EMYJ9QnPJEbVkjjD72G280YnnEv01fUWeCJlMai0apYNMk8cxoDB/9iwAQLfXmDJz6L4bAACvfkPO4xnlcQSA2FByI24VPPniDUymHtaPaOOdu3Xyc/ckFeyp9M2TVGKw7VOii1blkdv72Y9mn0GvU27n8MvUCQ9UGvSuhRSzS79CByzunEbU1ZpHLtIQx3MqOZi939BjmdcmWXnx3UQmzX+A1DV02qcPIGcTk00Jl5adevyHlhApT/x6Dr9LY7WlvjsYDrR71rkAgJ4faW+zdzHHL78nT+c9ghJB7s30ABoeXgBAJZ8jr1SmIUV35XPj2UEPYJqdvJpXm3QeZxSR/spcIvXpnRk4mjOBHvHENhzZHbW8fxVBTP63vcY5Dj2biN2zmgKCjYPOMvv0aCEabnV72kWjSkrZIak5f8QshGWZZZb9zCyEBUC4WuGoyDXTY+za0YGBCfTiBNaqVBAlMdvXS8UgHaTcbkknLRnjq7iwwjqu4FmlTGc4pTORUX2bpMrnTyNPkKtqDWbYiNgKJLkyH1WdJ2GUXrmag4kYHBvJZZR3JydjZI+UL+DnzqShZp/YJo5/e9xINSauyIa3LcWpV2tRxvionOsoZhflxbQS72ByHHO+oYfx4EM6uXr8h+RrXplA3uiivzPR+KtHmEpx7n1aqmTpo/xsl/K4ThpEZLL230QSBkrrc9s5Zp/rMnj9cxZyZTdSf2J8iF7t4muzbZMSTeo8lzzO9l1MpUlRgnjflDTgp3aqijn7Jp9ow3kMfxfXnEmZHP9oIsaCNUTouz4nMmqt1bLNnV5W8kD7iH59FV+Xojg510WUQXZ/84LZp1op4XpdPJsf1PO+SCeR+qHHZpttG0s57i6PMRbvsJ0INEIhHp9WPq+fNekk/ewWPu+nJ/E+CJXY3GUD57JqpPa8buzH/w/awfqbeRfQQ5yvam729OWz4ePUu4cRIo/XFJAEP9vxC1lJoD2UGP4nZiEsyyyz7EiTgMeKdAf6ZfeSqxfNw03LqwHoSrsA8MoZjIGxNTNOZl4BV4opBeQ8xDCuYDvbFLVNCSF5ZUS/ywFcPb8v4IrbM1rXCwxvZUxQ8dNEKCUb6YXxe5V901YwGbdm4g1mH2NmjAIDfTbT2yUmM67I2Ob77vve7GPwWUXKM5ciiTpslURezoIcs60Rs3XgdXJ56XPoMSt5jOjJENrzjdACeKUbGCeVOJEocvebXIkjuhI9NVfoqPitcxkn1XUCY45yvs0DAGTPpDRya62SesnVMVBbVhMRGhyTkUR88Ugl/3KpRrizL9PePwAIcRCF/ZZ08fHYldMob50ynlH3j9/CmKibVLQ/ABxaTiTe604Vv2QgK4V0vScrNOPRY6x5lwg38Gp64oy/1QPVRFgNbZKto1QsW+wyPi/r+vJ4EX78PKuIXFZrVz1PXq1EQ3U2oqMW9eBEOfls2Kt0JH3OHCK3tMvpMf5A0ON6eha92j6VeQCAPG9dQmH1YaK+Mw59huG3PoGN+/OPKw4rpWsvefcbXx5T26sHp1pxWJZZZtmfaxaHZZlllv0lTEqJ1hNU1L1jX1jOFtjKcnH3OG5JYqTevog6pr1U+jJUIbeSxOSqDKYtDFeu21fX6u3Lv210O8sJDOQUKigzRbn+Q9vIW9uLSNQabnq/25nK4q+I+yU9ZvA87+o0GMMGnkmXshhAghv7Se63pjG5uDxFB15GVFObK62OW9CW3XSz58+jjnfm3XeZbUvClT746ao+oKqJGHsyK6TsepJaUcnjtYvc5uAtM2r29XqAWwYRROfBD2dfa7btd0E2ACBmMEMqvvmCQbdZatu46XNuGY26iABwz9/p/n/oAQa6nhTDbWnVAW47tr2mVVyNen6GPlWD+/dvBXuH0POypYZbT6O6DaC3lodUmETZDm6hsmYyPeuBfUxDa12vtZtsSrO9dgNDHYIvpfPAT+mfOVW6lfurZ80+YWdR5VQUczuZ++RjAIDoB6j6vaZKz09fQ8U2gUntw+tVWlaj2g6nMjA2oXi72ackjHRHtQps7mRjmEqZg9u8qCh9zWn/YFK7tPPhPcs/lIdX28h1LXx+h9mKzT5J6arqUX00hNfx/0lLnLhqDRbCsswyy44weQLLy3ToC6vVEYBDMf3hrShB1/IPze/sIQzObOxFRDU4KRQA0FepQDpV0uycblpGfoGDSpoTN1MyxJ7IAL10FVx62J5qtvW8RDd26U1cWbPVla8qICFa1USSPOj8W3UfX4Za7K/ludO2M0jTqysTm/33EDUFBob+7FoNFcuooURA6SMYOvCNXhgx7oc3AACOdCIteZCpP2tvn8M5+IDXbkjjAEDVfiK3xK6jec07mESc+wKTY3tdNtps+/GdRCADDhLBzdpDInXvXUyDiksj2rjnGh2W8e8HiaxuvZbz/NwLTLa+4gKO8Zm3NXL4NTNCIEpajp4nkpUWCgDYs5XpJVVOvRW5YzfHX/oWCW5nAxFo6UomK0e1Msm97oBWTO1+AwND97/JviEXEpnvuPsfAIDMi6gS62nW+vC2ZqLHA8HdAABpt7A6kmsLg2WnRGmCe2syEWi3IF7b3Hwiw3CV4Dxc8HnyVOkk+uDYHgCAmEoqyrqU4miEgy8FuU4r78KLyOqzQKL20xM5tqAWHjfzHQb2ymvv1X1U2pqz/3RI/8fQHma9sCyzzLK/hElI64UFAA4bEOXvBZ89ywAAjRN0RWCbSmlJLiGvEhpNhNJUTN6i7ByukBlemvea6OEqWRlPt7afCv70V8GnUYueMts2/pNoJdHFsInlh8knjIxTK2OIWtmlXuFbPDxepD8Rg1BVnYVyLTd0YQJvfRtUYCRZ95XkKTY3sbpJxCJyZj4jbzLbvhXNasozY7mqijxqove7i1risoS8S8EELfrXaTpDHrz20X1e+MVcXl8p56WxWHN8l65ges2hNxgu8b5Cr6f8k+e12RkiYVSYAYAz+jDA9eAyntsIb6g9xHlrWxfuDFUPsLiQq//3FURAv4Wsnt1KXujw26yzF96Vwbjxq4k+Irpr2ZdP+hGVDrwwGwAQN54hI1Ihq+IVRH/1RdVmn+gzOHfVB98AAHx8mCM+959Mfn4wn7zR3b20znxdLFFwZSWPG/YVayQaYR/+N2rUEtzEaxMtPOe0cIXUVAXrymgK+RU/8ozZp9ObDHH4bwkFE3urgOahkpyZTO9ttnWHkZ876zDTmup9VcSALznKoNv4TAsV3AoAHh/uTnxzVkG0/DxY9/ealECryyLdLbPMsr+AWRyWMiHdcLTU4lMVDNe/UXuV0io2AwCcSVxtytR3aSPJGQTtZRrDY85+Zp8LVPLrvV/SM/RKDI/RWkWexzX1FrOtn0ow9TjI24xxMrna08QVXRykCJ0tKsnsU+CkhywukChMbCVnJZPJ53h9ST4h8iSNFL3q6I0UbnJiLTaKCvqfzoDUPbv1Cjgzm2hGKM+ip46ozKsPV2mheLtOlZvNPoXPMVjTbyQ5DgMFJI3lvPlEhptt818jmvnoJSKRG15h4vLCWQxUDQimh86QYgaAUJU68+x7RDx9lce138eUS0l7VcuyvPcgucMkvyMfo+f2k5t8qR8F/QwPIABI5cn9+HlWrB43nqReWAbRx72zPjXbGhWZo08lMnRnkmtzfcp5T7yHieXSRwcItyr+sst8jm1wrUrjuYNBofc+xFSjmohRZp+gBo4h/HGmQPk8QkTqqxLhvfctN9vGdBkNABC7OD+II296OI1oO1wlaEf3yTD7vLONHvApXYjudpbxnslAFRDcBtWLHcsAAM7e9Ej7K3nmxdW8R6P3kEf9sdeFZp9+m5SUTY8RgN2B9jDrhWWZZZb9JayjOCwhxGMApgJoBZADYKaUsvo3+3Rkak6v7L7y6+9WwO9t8lFBPfXe3R5DZPM1mOh6UhXTXYYtCQUAnD2GnpWbM7RUiWghb5MbRL4rvZacQFkU447CWjWf0+TH1c2oMrtb8S19SsgFFaSrFXLev80+gSPIjc0pIldzYxrRgcefcS+VNq56qw9rXu2UeB6/4WNyDf5dlSBgT/IYRqwVAMjtTBqu7kduLLKKPEjzOhYAEMpjBJtmjnw6MyZrZwjnrqszDwBQt4Arr5G6AwBpM84HAGz/N+ta9nyB3raWJVyRN7/A+KW+t55h9tk8h6lKva4gsi1T1a3f+y8R6Y3/vcBs+8M/KYUSr6RtvAPbBL4BeOoNotZnt2uRvvKvePyIi4g4bTXFR1xPyYRxZttBt3P+W6rJke3+mAUZBnxFD6CBYj2bFpp99rxIdBf/KpFa4HKe26cruaCdAXxWurZoDuvzOsb+jVLoMlgokUWVnOwZpOdHLqC32WsEU8Xcq+cCAOxDpgMAvikh3xlysZY9HvwQ4wRvrqPn9akkCjTWdCOCbG0j5eKtEFpYNcc3ax3R15yBxBauiFSer+qQHpNfKADgXxtq8OJ1Z6Bw7/bjSs2J6dRdXvDEh0dvCODJ6T2PpwjFRADfSSldQohHAUBKecdv9bEQlmWWWfYz6wiEJaVsW5pnDYAzf62tYdYLyzLLLDvCpMTvSc1pr1L1lwI4Kqzr0BdWs8uNnWUNGJlOorthgH6h+sznFmpyDEnG/G6nAgBOaqB+1I196br1ODWBu8dGhQJDVsuZzy1VaEwXAMAP1X76+PXcinX6lGoN6SrF5dxAKoPecDWrzcy6eo7Z56QKbnVuilRVZejZR95D1Nku+Ru3B1OFDguA8jYbuuwBvbkNcC55AwDgPVLrbXkGUl0i8GvW6mtWWz8jiNY1nNsvv4PrzD6ueBL+6Qu4vfMkkfQNOpkkbPE07TRoWcgag70f5RbceAQrd1OpYt5azm2/NmXbt2+lwyItn4GPhjbXrfMYFuCu0JGvfa5imEFwFh0LBz7igvnT+ootW3X1Hv/oUJ7HQ5I94l2mokSHcnudcf+5+lprGTQZNoX3qE8st/XYykBLdw23/N7dB5l9ejzC4M/W7+mc2NePGvSdQzi3nZUaiMs33uwzzY+OELcXt4QNbj5RgWpLLlZ+YLYtHkEViDh/Hm9FZ97PMXtJYQzqRj2y9W/P1dexkUG9KQl0DtjDeO2HlTZbtwPfmG0N3TRPNEn7OZ34bLVEqCpG6i5ul1rnv3cl29wxvDfm/WRb/kfsd3JY5e1Qqv4eAC4A7/5CuyPMQliWWWbZEdaeYQ1HK1UvhJgBYAqAcfIYCPUO1sPqLVd/t9DUupru0WkengSujNhPNFHWhYgnElz9NtXQXdsjWqMmv1KuLAubuVpOcuQBAFyRXPGNysMAUJrKFSpaVeo99B5XzfhTeJ66gVzFQ/ctM/sUqUTWBhUYagStGjUOsfoTAIB3alezT2M8yWMvtRK6VKilQzkIXD5a26pJBeeFVrEysGsPr92mUn2EH1fk1r2bzT6OsSqodBvHefBjpbV+NRN4DZQJALv7EHUtyWHwreGwqPua6MM3niknNSN0FeSIfSrV5zW2qT5ANc5enzOtx9agHRlCaUqVvczAyvDBRJM/3MSA1eFPUjds72taP73b40R9rlDes/pXiXgbyxjSUb1fI7jQTlyYI3oTMdtPoc65GQagKnvvqNCViKKVXlWYL8lvx/q5HHcXojDnDxyLfZzWpjfCR4xq3aUBRKnRh0ny334g2mx75Tyi606q4tM2G9smqbqWxl/TxiKtCDomnLuCN3P57ZCnmKCedftN6nJ0oK0R8hOmQkXGe+UBAJZ76HQaFsvP5dq5Zp+KfkR5gQ4bRo8cjk0bNx4X6R6Z3k1OefCdY2r75gX9jod0nwzgPwBGSSnLjtYesBCWZZZZ9hOjWkOHRLo/CzI6i5X3fo2U8urf6tChLyyXsKNcBGJaOFNnWn/cYX4nDaXOdLq144wE2iaijOzdTJfwqtMBee4Y/n+ShxzTTl+GRGQ1MFDP02mw2fbDzfzM286Qhyv/TjQglBrkjjJyXOmpOqAwvpFcz05Vbbp1AQMxa3LIs0XcTt6tro1bOqiQCczb/Ym61h6uBgCcsohcjftaneYRvXUuAGBbJ6bK5CdwJQ+/nNye+x2GDUSM0MnJgQpVhB1g+EL6XeSnpDeRZ00bqZuU94lebpgxGwCw9TxyZr2f/BcAYMnEKwAAw/6hUVPxXrrLM25jCtCGaymH4/mG9RURoBGira8K7LyYiGHbLCZVD15HPmfzqeRzes7THI1UaVleCp35RTNEJGgGgzaL2yjKRkXxmmzr5gIAqhSQ8lJcX9PjRCjdBulgYiPoFrkMx9iQPAkA0Meb6DJnCK/5ULFOfp7YwvCLqu84zqv8ibbvmcQQkurGPLNt8hQ+H+79TKPq3ovjd32rqtnk89ke2KY+ZMEZvLaLu/AClt3H6t+do/jc5Lv8zbbTg4jUPIvIW7tGktMbsZ+Btu44nt/eTd/nmHo+p+7QeNjQDjsm2TFxWFLKTr+3j4WwLLPMsiPMI4GWv2ouoRAiCcBbAGJAtPiSlPIpIUQ46IZMBZAH4GwpZdWvHQcAnG6JkgYXotUqUDT8cvO7BMX5+ChBvQ93cEs7aT5TKXZdxoDO0CevN/uU3UTvWvd1TDXJnEoezA1yM/Vt9OQu68M0Hr+t8wEAtyyld+2RkyiEN8zNVUoUan3t1r1cRbNGcZUTqtZc9Bgm5bqWEHEFtOGwWjOI6lZsppftiu5EJJ846GU7u1lXzTEeiRwlEDc9lNNXN4MVdwKryaHYWnXqTOsBolJPANHHgnoGtY4/TO17x14dOCpmUIywUpUD7v4m56nkGUqTZE4hIm0orjT7xF57J/+j+Jysc1VtRpVwbBt5ttl2RwuvLfp1pr30+herEhc+wqDQ3jcRKTpUsjgAVK+gh8/woqY+puSDvqTsT/fTbzfbFt1NvXTXXfTGZpRsBgA0JfUFAITNYErUmxUxZp/pQfQkNvmRI+sjiJyl4g4z19ERlZSfa/bZOJGSQr2upCDjp9s4Rk8UZWFeHqiDlZ37iPjL+5wOAIjJp5ijYxCDXEMSyat6OmnPJZTW/c5q/hwQr3jYJj4j5edrz2jineTWHIkEHwUeVSU6icjqg5V0Q98zVF+zbS/HUOKfAqfnuOgrACe2gJ/t6E3gAnCrlLIbgMEArhNCdANwJ4BvpZSZAL5Vv1tmmWV/dVNewmP519F2VIQlpSyCii6SUtYJIXYBSAAwDcBo1exNAMsA/GZYvV9rLbrnL4GrN3mFrbnak/JOEb1o92QRFp3Xg14Rr2S+ByN9uMrZL9U13OKDlXdHVerNrefvyQFcZVqf1qt18WXkkJL3kGN6chK9MR4n0c2aM3ncrgt18G2A8riV20MBAC9X01vVXQn7TR2t0lTyN5t9vjnA6xj9HJHg/Lsoc3x2NK/VVqOF3UQEUV9cION+bC2MEfpx9CwAwNhaIqymlAFmH+8ozku+m4jh5DqmIy24knImPTfqmCeXQlYJQknDHGaSeNQpjHGrziCSC63XqHKXh4ht5yC2OeVxVW9PVcFuXaHFBL2/WAYA2PN3pr/E2phOEncZEVZtOFFsw2t/N/uEnHsdACBgPdNpSly89ggfxoKVNWlYnHAaxfZsqvJQbQIRbtN/mNTuM5Mc1kXYbPYR+bw3/kV5AICWIUQvfpVE0LYUouGWoeebfXq76In2KmMbjxqLbQvHWN5d13qMUEgtVonx5cYRURsJ8r5KDFA0aNQa4E2U16OM81/zKRHcjjM4L/3+pZP0bZHcHdyzkyjsoUDya64Y7gTsKol/ZbGep5HRqQCA5QerUNd6/BWL/r/RwxJCpALoA2AtgBj1MgOAYnDL+Et9rgRwJQAkx0T+4YFaZpllHWd/+ReWECIQwKcAZkkpa0WbqspSSimE+MUrVGH6LwFAfOce8l8NPfH3Iq5OJydosbYQH8qi7Pwb9/DxL9Hrcu18rq7vdCUyerShu9nnjhB+Vx7IKrspULIdK+ldC+2ZZbb1DuClfjuAHq2CPHIyNU30kH0znXE1X9v0dXllMyG6WgnS3TqM5zHipw7ezrE2lWukeMrz9O54XmKcV1alipJ3ceU7Ai2p1biH8vDVC8ZwHUwkkti/i3FkVz63xuyz7Eyu8N5BjAXbfBt5o7EvEdV8U1hntq1Xq+05Sbw1wkt5oFSEeNhBJbETrzm4DCU0mJpHGWJvVcn4gJNj9IvT4091qSra8UQkrg1EWOuT6D3MepMezKaLdGEPv4VzAACNp1CUsF7JCPlNIiKN/lZnddhV0Q/XNsq7NKp4I7vKUoCdP4WSeAEAUXdkOE+dKpBR7UtPb0gI76H30tfMNiVDZwAA4rzJT1WkEXnWq77JbZLoXeHsL9YwudrZjXO3uYTP3rJc3pfb7DoG8KDK2khJp2c6LIQLd6hKi9gSO8Js+/AiovoP+9Pb6FYFQ0QEhQ7Xq7i424bpytKoIGofnRqGIO92KEIhAddflXQHACGEA3xZvSulNKIAS4QQcVLKIiFEHIDSXz+CZZZZ9lcxKU/cys9HJd0FodSrAHZJKf/T5qt5AIxw4UsAfNH+w7PMMss63iSkPLZ/HW3HgrCGAbgIwDYhxGb12d0AHgHwkRDiMgAHAZz9y921RQd449pBiTjYSpez06kveFg0txePXMZS3fdW0D385rmqpt4BpkDc1qhr0B3wng4ASGskaWzoVDkyuaVa7tKwOaWFEHeKk5ewK5XBmBkr6TI//zJuFT/YoYHilM7cRiTNY7DnlpE3AgAGBJKkDT6PZH9J96lmH1sTAy/LvbjFDVYVUoz0ntBWvX10qxSfOT9w2/i3Wqa/TLqaRG6YCiJcfE1fs49nH13YiWr7Yn+VgNf9HdNhBg7QIRCRyqVvO0TitjCBrnZHHLe9zQ9fAwBImKUrsJROIJGdoIJvd7SGAgB6VjFtSLSpEORS1WT21fLauqj0ly5+3CLmLVTBlTP1fS7blQcAiBvKdKSgSM7P8sOcF/fNb5htJ303HADQMphhJOFqG1dzFR0ord/wWfHpMcTss/c/DOaNeZpb8pg8Bly27uccPBbImo+3jdPOmxiVNmXoa92mFGynZ/M5TQ3V2+xcD69fqJSo4IcZ3rCjjOk3PWI5/wWvzDf7ZKSSxrjpe+KD29Zy2x0/nVvFtC36ml+8gFt8z046f8q7clvc5OIczp3ELa/M1TTBoRhmxiQ2HYZD6jSl4zF5giKsY/ES/gDg14I7xv3K55ZZZtlf1U7gLWGHJj93791HfrhgGaL8f/6eDAVJcNd8poDYp5GU9VKk9ZnfkKD+ZKJOfi4MZGqOn4Pv04ClDCFoHMOA1JA27npbK1GRrCNpKaNIYtqaeFyPQizfN0aYfYaHcdUUqiacazM13WuGUavcUIo8WKPTPAbmcWXN6z4dAJCWw5WyfgsRSvCUi822P7TSsVrfQuI5I5xBgsuySGxfVLiZ11e01ewjm3UV4raW+zznLe6xN83PjPH5CyKHDWXqPB/NBgAEpRNBVoy9zuxTWMcVOjuSQY72PVRk9XQmIvUq1cnVUPrpzhyOz5HOQMvSD94AAESfw2tdZ9ekeH87iWZpaI+rNJv5FZz/yWXf6rH0YCpRpQp16F27+ciLVqS/8NWa7lJVShYqXKVlGxFp9UgiqkgX77+RuA0A+TaGcgR6q7QnF5+JZ3cSoU7spL3bpfWtath85gbF89xeKmxig5PpVX2LtQ68pycFC8Q6siYLorjOj1cVhPLH3Gi27SToSJK5dDJ5elCp1quaAcf1C5iU7D/9GrPP8kqmAXUK98Op40dh2+bjS34OTOwis2944Zjarrxz7B9Ofv4jZqXmWGaZZUeaBNzHLuDXodahLyzfllp0zl0MWxJdwaVvPmt+d/gqpt4kjeeqvLaYq1uvaCKhj/tzxVovO5t9+tfnAACkCuTMH0rtbCi+qqhNaFhaNFehBaoyzUnB5LvywRUxZSXd6aPaVJZeVctUn0FBPJ4Yw7GV13B1NiRM+sbqFf7pQ0QiNzm4wttUhZ2GBQsAAE2BKWbbeMVrpQYRwcntRGMlGxj8WavCKfL8dXhGls+RK61fJ86lz/3kdxra1EjcUcoxDE1kbcR++xgqYhtGN7qnH7k3vzZ9+tsUKlVxj3XribCC/TnHZfM+NttGns/E+gM9VJrKJ0yjCs4kd+ip5UEG+GoZodZUokeHErxzpzJxOTGY6EZEjzTbRiiJlbC55KwWDScSGaKq/PirgM/9N2p5nIwXOb5iFS6R0J9tc6uJlit8yBt2q9li9lnXwuDVRifn+4Imzv/ETPJdXRu1QGNOK69taBLDSwxuyRlIjjV7HQNrRYTWrDtQx/ntpHT9T9rD49vUsxb4vA4clTfOBtAGlW1gytXXEaMBAKdMpmTQoX/pxJIxNzFeWx7Mh3er5tv+uMm/LodlmWWW/d8yib8w6d6e5mqoR9Wq7/H9JKKQKbfqKAn7dnr/yjpxFQr0VgGF25ke4e7FYMTIei125lzLVTp/IJHPK2vII1w6gKtgYrCu0eYlebx+cVxxK1WCbvkMrt4YRgE8o2oJAAwSit/yJ69lr6PnbGcpV+RTMukJvOMbzes8MZHn/ng/V/8zKujNCbuTnqH8Wu3F6ZRHMUG3qkFnCAH2jiaX5VIPTaaf7lP/CZFV4AAmw+55ggng3kH0WsWep2Wne21gak/1JZSZaVq4DAAQfy9F9Cqf4Mqef+FDZp/+dfSSnvMjUdnz59KD2LKEHFnUmboeHuoZUGl7nIndspeS/lFaSp40RW006px4r90cgzuVns9GOznJ3h7KwbgdWrpYUUpwB2jeEgD8f6RwoiGx3flfj5vfuZW433Or+CxcPpD3I/sHelF3DGHCtCc80ezTV/CZSFJe2ZNe5nePpfFYdUvnmW0nnzkLAFCt/p7DK+hRXNjCPt2/5U4g/ibtee1SpdCcD6/D1ZUId+tMyjc3Pfm+2bbOxT/JWA/Re2BXpkSNVh5lUU6BQ//7XjT7eJyc37ykFLR4B+K4TQKePyFk4VjMQliWWWbZz+xERVgdK5HcJ1uuWroY9nrlCSnaZ363PY7cxYdbyNE8mEo007yJtfsqT6IESNSqN8w+nyTQi9Q/nqtPegDRl2ghuhGt2qPmDiafdUCFQYUqgcAQ9dPRwPiWzU0/X6F6KiG52lauuEZV6i6HuZq+IXV9RTGJid0hDsKDcTksKGJ46hyHNHdirPKimDFJhxIYT5SkBOMuWkrv4xspWjLGnsEYs/qFFDT0ODkW/4vu/tnxDend9QEcX0Y4kWHDgyr+6iwiFKMmIwAktNCLV+HPGKuoSiZXN8XSA+hbptFkYyT5xMIbzwMApD+qOEklMri2hrxhVqRGSOEqvu6bJh5/sOKjQg+pVJZAXbk6x5epW+F+vEfBm4l0mvaSE/NTaOdQq4/ZJ0GhpG3TKfdif4UpNIaHcXc4kV1bXsoVzev44gCfl0kZqu6kSh6PbuPVFotV6tUEIvLCet7XNCef2wNeRIj+z2leKuYmIlwjTtCrnClMOd7kvTJKdZGRW/fTY3lyNz6vYX68nv6tnHd3ID2WhncbAKCkf1qT+2LYsGHYeJwSyQHxnWXWZU8fU9uND55keQkts8yyP8+klJaX0DRhgzuEHpTdN99sfjzvSkq3/H0MV9XCJnIPceO5CjWrCbQPPd3sc5ba18ulLJggBhNxSS+uuGtrdfmqoU1cUb1UlegWFaPkU8HV7tG9XMluHRRi9ql4gjLBDTczojpkreIaBhFRGFIg50TrIgUblVctK4KoYn8VV79+Lno0DR4DAIQqWeY8zO8Kg+kxi9lM+ZG/T6LXs9xHJyfXK5SXPpVxRcZKu7+Bi2qmQ0vztiYQWUXeQS9awDgiuOC7yWF9fpDc2BnVO80+lUq0zlAXdMbQQ+lQEfqiWUfqG3bfcKK7N5Yzutw+kWPLCOOcBjl0BtgapAIAxqeRp9tRzvkJSGd0f3Mbuen8Qp4rTxFG45OIhAKUTHPrQsbd5fbRUeuJgURjfd4kEpryKa/ty95E0DFJfOTdXnFmH/sBIhyPpEc3sJyIdmEN7+vUw5rDso2iLI2jlt7UwFc4l3I0UWpGqopIP+t+s880FRNmUzFuHh96lZMVGnT760yGbo28n0V1fDb2VbDvFjXeSxRKdnvpZ1sc2sZ5qnEeUUX6eEx2wPtKCPEAKFPlAXORZ0gpC3+rz7EI+FlmmWX/h8xIfj6Wf8dpj0kpe0kpswF8BeC+o3WwtoSWWWbZz6wjSHcpZW2bXwOAo1fQ6NAXlhQ2OB3+ZnBj1mvanTu4kHC5SJGYDywmIf/SKdwaphdQn8mVqvm9fBXiEDaCYQ1+8+je9u1DAr/E08Vs+56TZOg5YYTYoqkaANCskpOvH8S5crXRw9qkYP3YxapizMlMYQmr5/aiOUZpyLe5ub1USELgNqbotHzJwD9cyTCKklA9pm2ldA6MS2Q4QN9Y9m2poFOik43u6j1NYWafLl78zKa2DsudJO6HFzLotLWxTaJuILeSEQ8wBcRL6ToZoz01M5S/l2t1zKCfPBGPriRCv6sft8pGEjEA1Edzy/mWSlC315Awb7FzuxJu5312lGiCe7CH93lVEa95SBO3M56DnNNZB3VVpP/60+HiowIs9/rxPJnRPH5pCu9zY4neph5Wz0R4AO/3l703AgAOdaFqaHITnTkHoNNtEneS8D+jM5+9giCGjJxuo+77yPk6WPk7++cAgJqhVJu1KW0uu0oEX9LAOciK1Fu2Gn9FM7xOABHYlffFNug0AMD/a+/K46uqzu367hQyzzMJCQECYYqMIoOBClIntK1KsVWx1tap4tOnrbRPO9hq1Vbp62sfapXX2qJVa7EVQVFwQEAGEQhDIAQSwpCZkPkm+/2x9jn7QhWi8d3cPM76/fgl92bvc/bZ53D22t+wvtfKTdjKdY1M//Lk85q7dFC0VcX8z6UMqJ5bb1KY7m2kKeGRzFqEiQn7+dxQwfMSisiDAK4F0ABg+hmaO1tCBw4cnAwFGt278w9AkohsDPh3U+CxRORNEdn+Cf/mAIBSaqFSKgssU3/bv47mZASVYXUqpo7Et2mJjHBj4M6L5wqSvoZs5smZlBRZW0PG829LaYRcd7tRf0z+G4PnwtJoxPcVUeGmxMPV7tI9/7TbHi+klIdLV1kuC6dxX5oYFpBVwgDVjkP77D4zL7iev2RQ9usnq8sAAPePo9FUljMY8Z2h19h9xmVwRZRRTOtIG85Fo3MHV05XvEmzGa/bvn24EADgrSTjSriIWvTDOhhikBjhtvtAF3BpTeFxJq0ie2qaTgO99xVT9zBvPK9N6e61XgbAWkGBOjYX63TlHQAY/wIN6PFTigAAC4fxPG3awO2bYbTQa1q4miduoyzO9oFkMZGaJWdH8DzHVxgd+PBrmFISUaeDSyv5LHSMYZrQgKYDdlv3BJ6rxap4o0MqusppFE8fkwMACMswkjoNOi3LYrgfZjLReNw2MiPl0+xv1MV2n85WPlsntMMkI4ms1arw/bdbBpprfvx5AECaTlBfeyVVVePjORdFHjo9msUELUfvp8TNsWupvNr4LLXcE3Wy+JTskXZbVxorkXdZydklZH9T82iYb8+k8b3rDbObemQa2eLb1W40+nteNeczMqzq04U1nKlUfQCeA/AagPtP18ixYTlw4OBfEAx5GREZrJSygjHnANh1uvZAkF9YHuVHfHsNxM89e6vL7PNzm+h+/voJMpL/0UF2I/pxiB9MZ8qIKq62+7w/lWJzX+5H0bwurTO/q5pMJW/4+Xbb2A7afFpWU/AuO78QACBu0o8VcRSLmzV0it1H9uqqNQVc9X40laun5wjTMZR236fWmJubqBOi3XUck3TQ5rA+ndc1+h8mjeSXyWSR9ynaajxZlGF562JWUG5+nelKhT5zfP9bTEupmELmvUEHz6bpEIAJl/+73fa4thV69bw06GTqg1oOZ1qqTv8IM49B0teu57Vp6RjU8DpcWrjP/h7AwLeYbiQ63CBa59IM6NIiiCV8Fmu/cp/dJ/M92i2jzmE1G0+a1khvJJv84TnmmagGmWzqAYYdqCgyRH8VQwqueOYjAMD8yTl2n0t3M8TFr5lUZj7vmXsQA27bkljvL/qdP9p9kEUGdWICGXqxLmgZ8TOm8WT/8CG76eKZrIT9lViy0olaruaGf/CaF87kXMSEmbiARUfI2L67gilMuIl1HPfqwNRKXXUcABLDyRZLda3K2QW60vNhPnPv1XNOsiZeb/cZ0kI749j0bER4A9h4DxCkgPKHRCQfDGs4AOC0ZeoBh2E5cODgFCgVHLUGpdRXP2uf4CY/iwdVngSktnHVfvQ9Y6/47gR6z568kqu0R+/7F1XSHpUVz5XmulyzR5/dTI9PZzSDS/+0j8wtkc42dKw0lVEaZi8AAMS4efzqfLImqzhIrGYdr5S32X1mbuYYVvXjFn1Sf9pSkEjbQ3kNz5cQkLrRaEkh67QjS1I4O5kBf++MM4vIf0RxdW5LYBLsIW1Pm7aZjKvqITJIuethu091EfvH6iTtif11WlKrrqnXblb2SCvpuI4rcG0K7S5jVtLO5Z7KOZgSZ2R4mpJos4o8yvQXlci5laMUUvS/95LdNnw8zRO/r6IN8VvFOsByGJPbO3Rdx4D6LujUgn2Dmjk/Te8vBwBETL0EAFAea2x8/SvJrN7yMqBzcATtnJm6yvLLcRzbkq1H7T4Ns+iNTQRZdqkOTG2O5ijyj/C6Jq41Mj9rb+Oz176IzDZrAYNBvQ+x3mJgMeWrR3B+rWBYKaaXM7ofn9OGVt7D3FgTIHzvZDIsVySTnq2kmrR/8j4M/JJRF/9TJe/nV7axIrbnfNpe13joWZyeoEULS41AoMrm8xjl8sP9ycWrPjNCVXHUYVgOHDg4GUqhy//FaMN/0Qhu8nPBYLXuuUVwRZCpLNxr4ousZGcrOTU3lraHlaX1AIDZeXEAAAnIGZAN9Py8GFsEwCSKzoqgPcGfPMhu663U8UM6MfdX5Tz37W2rAQAHRnOVC5SXSdD2qA692ljJsJlv0zt4n48r/aMTjd3Fv4XxMZ3TrwcA/GU7x3K9V6e/ZJg4LCut5t1OMoX3y8i47tGZOJ3bybQqCs0K/Jv3yzj+cziW2gTaTFp0QY+0LhNTVabiAAA5lhpfKYtCuDLZp30D2U1YoamL59dxaa599E7tSqdNr6CdKUyWdxIwXsKqZq76o9xV+rrI7DrSufJ/71WTMP3bIZRHaRlSBADw6aIJnpoyPSlmDbWSgwfVk8X4NctrHUO7XT9FNtz+8uN2H99lLCZyTNHWc1hLGo+O5hhVGJPbPSWmQvaeVBbPeG4LmehPB/O+WAxxQ85FdtvhyaTvEW7Od0m9ToQvo73RlrAeY6pFNz9PGaUjc2j/yojiNf7netYe9AewmTvPIxOs0bLQGWH86dbVxT/QsWgTEkwfj7ZvdSX0x7mz5mDT1m09chX6knJV2iU/OXNDAOVLrnWSnx04cNCLUIDq/AICUP8P4LywHDhwcAqULU0UagjulnD0SLVuxd9s17jyGS30Dq2U6GtmYGjbP2l0FG0k93yVwZTqzaftPm6tm90wgvR7h3YPR2iD6Dk+sz1Sbm4xrXqB1lUXV5HCD36KBtfY/zDVQiJbGELRFJ6k2/L4E12k8m0bqNP+XynG2XHLeBpfLRWI43EMUI3ew8BRlTXcbrvbz23p4FiOt8HPn4kVWhsqhmoBVnUdAKhr4dbmywO5rf7NhwwHuG0CzytrjLt+x3CWdh95QNdy1Abv9tIdAIDwSVQ6bUobZfexdsQ+rUZg3avOD7l93DfGBI5a1Y+Sahk+UxzGLfiQSG5jrJCO9+qMXlVuPLfPGdtZQcallRdODKMBP2rnm3bbilyGgqRF8jzP7+CW8/wczpuO1kDapuftPlYFnfoNVHqNvZUhCR9dymekcBmDiV2bTVDxmpQiAMD0cB7//u2cp7umDDjpPAAQriN3recp7BD1x2pTuFWzniurghMAuGcwdUy28j5UDtNpQnW8D/5445b4837O3cT+cQCAwUd1/UHt/PAXcyvrn2KClffXc9sb4XXh8pk9r5rjSxigki9c2K22lUu/42wJHThw0LsIVYYV3ORntxdtMZnwaLElf0AqY78S6rPP2xwHALh5EdlLwWrqnrdrA2/EARMKEaar90avpQ7T5GHUe5J6so7KtPF22506mLTguQUAgJJv/gIAUBSp69TdxoDLY4/fZfcJH8dgQ18dDefbB1LPPHswE3T/nnmVHluH3cdXx/H5dUXjKG1Yfz+Oht3zPKYeXj502ME2GsOXdjKZ+Duj6XhYd5THPTfDMNE9dVxNW7SvfaxWWy1rYNuV0SYTYv6bNPYuzmfazo3NqwEAh2ZSh2xgJVfrmlgzJktvq6CBBmh/fzIH7+giACfry7tKWfNvXRwTdbO1k2JLHe/V+BayzEk55j64tAps004a0iPnUpkzupYpUceHmvFngEb11k4ed+5QXuvBZvIYq2pRzfi5dp/4d8jAky7lvdndwPHmvUxG9fN3GVJzf7apajMtnc6a32+jQf3H/TnuY37NagK0oTbWtOk+/NLSXqtq5jX//oMyAMC9RUajy63vVbIOko3xcdxdXoY+NHhNitqMXF7bugpt+E/mczMknozOVcg+izcZ2ahbR5KlSnsTfDD38vNChbCX0GFYDhw4OAUKXSHKsIJqwxpZOEYte3ONvYqHe8xWu1nXd4t6hHrjkQ88eVLfndW0h1Q3mzf/nBRdcVmHOqgyrtqtI2mbOdRomE+eux4A4DrGlbw6k6wgejnVRH2DaMd5K2ai3ef8LNrVpIPnkTZKtxwE7WA5h2lfUEnGBmGxu06dPlI6lIF/lt58ZZtZI1JWUQPdfamu/KtDLqwQjLaPyDpbZ91i94k5yHShEx/Q1hM1i+zCSjkJ27fWbmvZrFpzqeZpsdjDWQzsTNtH9qpyCu0uVoJ0QjvtOTva4wAABbG6ynWLSf04OJ0Vjs77OQNfj77DQM+s66lwujmWDHV0bMAztpUyOI92UBJl/hjKwOzTyqwTj6y2m3aNpj5+10rag94toP1sTDrvS1wj2dJBX6bdJ30tg4V3L2Hy86hHtJ56FFNpOmOYPOwPGJJHM/TO8ziXXm1H3dZCZpsbZ2xwMbUMeLX05nOFDL3Wx+PHu/l8lpwwu4dwD3/P7tQBroeYvN3VxATmRcow0FuOMTC38wRTrcIup4CBRzPe3f3I3MvqTbXxCxWPt7R1IH50zUUoLf64RzYsb1x/FXf+Hd1qW73sHseG5cCBg94D6xKGJsMK6gurSymcaO/CUl0ZZ2H7Svtv846R2XzjBiYHj9RBmnkdZCqJ4VyJhwVUYHmuhPv1qw5QvuTXcWQzVzaRWVnVnAGgS4vvuSrp0Urw037kLqQIXHkK2cDIAAG/zld15ZBLFwAAntnBFfGmIfx5TxlX65sXG2XXzBlkbpYH06omDG0T2FltGGL2RDLBfVp0Lq+RaSMWG/BMZVWbjoDAQkvAMCpaey49ZHe7SrjSj80wlautAMUmzWi9A7mS+9t4vNLsIgBA9QnDRMdsZzpK5XmU1EkM53x0uK0qQ8agM32ZrvUXzmDS/YNoN2p++NsAgMP3kiVnx8TYfRIKGKR610f0mHmP0B6YlEKGWBl7oRn/Vkr+iJb5cR3mOC0ByKgEevH6+w3bcOvajs2P0d64L9Kr54I/67QttKTGJBwPH69tkfqZy9ACjYOSyKT31pl0rZRojtf3IFOkPDdrCaeXtLb7WNofTcgy4NUyMlUJFHx8tZNjmTeOXuCrW8zLwVfGtkdymYqWfpw7gqeO0jM6fzDHnZdqntN19fQ8L9+4Hw0tPbdhQSknDsuBAwd9BCFsdA+6DeuVN9agn7ZdBabB/HHrkZPaPvkS2cbH1+g2GUwn6dDpJADwh9TLAQA3x9OW0aG9UVbdt67ynXZbVzRXqLJUthmgGGP10mHaJ0ak0i4yrK30X8a9ycWV3KqE06LdRonHywAYjyAAHNLSJKkr6KGz6immqXoAJ1fymeSlTWNxBW0l1x9hqtGWQsbtDF/FY3ijTa3EQ9PJFLM30+4iWkalfixjwU4EJD9n6crV7hp6Lls3MxYsbKqOG9Micf7iD8y15vNvY4rJWj2FjIXafjttGhvuNRWH5w/SnqsK3quj2bSNlWvPXIGu5xjWbsTmlJfjdTdpIUb9H2O1lhbOtzLXYeY5dx+Z+NGhZKTJYXxmXfoYb9cZ1p2tk4731NArPD0nDgAQXkxG99gJMrAbx5oK0y3aoJXiInvx1DEF6GA0n7kdWsoaAJZuYgzeknH0dlrpQigkM2zz8l5FVhlppxadzmQ97Xtqydgse+zqfUaU8kfTmCj92DraQmcPIdtOsZhiPZ/phmQTz7enhgwz6Ve34IrnV2Lb0doe2bA8MekqasK3ztwQQMOqBx0blgMHDnoPtGGFZl3CoDKscSOHqfWvPAt/Qg4A4LVDZlIujasHALzdTC9VuZZ7uS6RLKR9Jysorx96pd0nR3tvrLiW2GquPlbEdWK48Wi9vJN2idmDePzcJnp71iqypxFv0AZRc8UP7D5Z4dzHN/7hZwCAFdMYv3S1j32tggz9hhvPYsWztJuVzv8lAGBSCsfwahlX76IBJubmmK4gPSBGi8xpUbnm/bRbtH+dtrG6VmNPuPUFRlYvn6/rB2qG4n/zWR7jYiOLXTyPRQ5G3H0jAGCJj+OcN4K2E7fi+T2lG+w+rXlkSZYDVz58BQDgymdfy8sGGCmdeC07vdVFe1q2TlxPPEavbUuGqYzt00J9qOC9+mk1bULXjaGnLzMyoMyA9po+8BaLQfw8n0zNigyv8+jCGAG1+NJayIB2uzjOwSX0FnpS2edEJm2VxwOYaJQWHrTYqUX8E4X3zL/csMqaWQsAACn9eE4rE8D/AiPqq7X4YmuAGzI3hs+AdPJe7W7UEkdN/Dw5yYzFU1sGwNSDvHM5r/211xgVv3Uyk+g/mm5qelrIiQvDZV86Hx/3MNLdHZ2mIsde1622jWt+6TAsBw4c9C4cL6EDBw76BlToBo726IUlIrMBPAHADeAppdRDp2uv2lvhP7AbjbocekGymZS99zFgdMZCJl22Dmeb5r8y1cIVQWPsVJiqNg0+po1YAaJROhxgYKROTK0xBvQoH7WyM97n8fw6IXW8ZQS+hBQ4PDIgmFVxy3lfGl3kdy9eAACoe3gJACBeJyer5nq7T8vtjwMAJoNG/a4PWYll5gSGKIS3GE36WOGW7N1DHNu04ZMBAJ6pDMTcq13vhRHNdp8VV3Pr9MJeGoJn5dGZEKfd+f5Vz9htYxZT/10OrAYAXDuYc7i12koS51ZlSLrR6HriAzowbp5A429EO7fm/o0MMfhdzCy77U0H/sRfRlMzKzqVwZTWFnGjj0brsceMAVo1cGveOZC7iLs/ZvBs7Tgmt1saYQBQ1kkD9o8jWVvQH89A1QueoU7Vinwa+ytef8fugxv0fczmPLkHMJTgYCQdI/OeYGDtkzeYYM1UP+9JRJipvgMAG3TFptGXBaRrsbQVVpQxiPjc5XzknxnLrfidWr9KYAz17qM0a1imiu8uoXljzQ2cr10tiXbbtdVMdL82g8/wAwd4PyfeyjG4d/Dap7rL7T6d+rmXjnp4lQlR+bxQSqGrIzS9hJ+7LqGIuAH8FsCXARQA+LqIFHxRA3PgwEFvgfIy3fn3RUBE7hIRJSJJZ2z7eY3uIjIJwANKqQv15x8AgFLqF5/WZ9yoArV+2XPo1BVx4DEuflc5DdhdLVyZOkfThf2X7VyR5xWwj7fCVB620l9aCqkH/tJOrpTfyOV72N1otL470vguXb6vHgAwJZvBjFFaisa1nikRltwJAIhmDHVxXJ1jPqJmubjITH7WxHSeK4abRNqRimPy72SogGss1Sr97/2VY5pmEnX3tfH6V+9nEOsFeXTtRz9Fw/+xLWST+d+52u5zuJBMbdNhrvCXpeqVUBt/Xa2m8nPnHl1tZhIdFVYlHzu0QAdINqWYdSbyCOd3nYtsICmC7nRLSiYsIBSlQjPbvFYahjtjGSqgNrLatU+zvs6IBLuPlS702E4+d+dm876+vosJ5nds/a3dNPFGJqQrzXwOPUC99qy76YzY7+X5rNQXACiu4vNTRPKLZi/7/nQV53JgMlnbTYONQ8ZKe5mzimP676vI3BN0taLA56ghgsb8mGKGWnSNIuNcX8Sk7UmLyBR3Zc+w+zy9nmElD8/i82SFLNw9hk6DrY2mhuGITWTvZZOYsJ4XTsZ24o9kcuGZvOa6om/bfZI7+Nx3RKVi6pTJ2Ly5Z0Z3V2Sy8g69vFtt2zc/1SOju4hkAXgKwFAAY5VS1adr35PKz5kAygM+V+jvTh3QTVZV2Kqauh6czoEDB0GBCirD+jWAe2CkxE6LnjCsrwGYrZS6UX/+JoCJSqlPLTctIlUAmgCc9i0aQkhC3xkr0LfG25fGCvSd8Q5QSiWfudmnQ0ReB6+3O+gHoDXg82Kl1OJPa3zKeeYAmKGUukNEygCMOxPD6onR/RCArIDP/fV3nwqlVLKIbAxm3EZP0JfGCvSt8falsQJ9b7w9gVJq9hd1LBF5E0DaJ/xpIYD7AMz6hL99KnrywvoQwGARyQVfVHMBzDt9FwcOHJxNUEpd8Enfi8hIALkAtgo1qPsD2CwiE5RSRz6pD9CDF5ZSyi8itwFYAYY1/EEptePzHs+BAwdnD5RS2wCkWJ+DsSWEUuo1AK99xm7d2t+GCPrSWIG+Nd6+NFag7433/yWCmkvowIEDBz1BT8IaHDhw4CCocF5YDhw46DMI2gtLRGaLyG4R2Ssi3w/WebsLEckSkbdFpFhEdojIHfr7BBF5Q0RK9M/43h6rBRFxi8gWEfmH/pwrIuv1HD8vIr7eHqMFEYkTkRdFZJeI7BSRSaE6tyJyp34GtovIX0SkXyjP7dmEoLyw+kjeoR/AXUqpAgDnArhVj/H7AFYppQYDWKU/hwruALAz4PPDAH6tlBoEoA5A92Qjg4MnALyulBoKYDQ47pCbWxHJBPA90GM1AvSAz0Voz+1Zg2AxrAkA9iqlSpVS7QCWApgTpHN3C0qpw0qpzfr3RvA/VCY4ziW62RIAl/fKAE+BiPQHcDGYhwVhMMsMAC/qJqE01lgA0wA8DQBKqXalVD1CdG5B73m4iHgARAA4jBCd27MNwXphdSvvMFQgIjkAzgGwHkCqUkrLZOIIgNTeGtcpeBzMwbLkKhMB1CulrLIpoTTHuQCqADyjt7BPiUgkQnBulVKHADwK4CD4omoAsAmhO7dnFRyj+ykQkSgALwFYoJQ6Hvg3xRiQXo8DEZFLABxTSm3q7bF0Ex4AYwD8Til1DphPetL2L4TmNh5kfrkAMgBEAvjCUlUc9AzBemF95rzD3oCIeMGX1XNKqZf110dFJF3/PR3Asd4aXwAmA7hMRwcvBbcrTwCI09sYILTmuAJAhVJqvf78IvgCC8W5vQDAfqVUlVKqA8DL4HyH6tyeVQjWC8vOO9TelbkAlgXp3N2CtgE9DWCnUupXAX9aBsBS5L8OwN+DPbZToZT6gVKqv1IqB5zLt5RS1wB4G8DXdLOQGCsA6NywchGxpE2/BKAYITi34FbwXBGJ0M+ENdaQnNuzDUGLdBeRi0C7i5V3+GBQTtxNiMgUAO8C2AZjF7oPtGO9ACAbwAEAVymlantlkJ8AESkCcLdS6hIRGQgyrgQAWwB8QynVdpruQYOIFIIOAh+AUgDzwQUz5OZWRH4M4GrQc7wFwI2gzSok5/ZsgpOa48CBgz4Dx+juwIGDPgPnheXAgYM+A+eF5cCBgz4D54XlwIGDPgPnheXAgYM+A+eF5cCBgz4D54XlwIGDPoP/BfxtYbZ0eEzWAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -518,107 +517,12 @@
     "hybrid_image_init = hybrid_lens_image.model(**parameters.args2kwargs(p_init))\n",
     "\n",
     "plt.title(\"Initial residuals\", fontsize=FS)\n",
-    "plt.imshow((data - hybrid_image_init) / np.sqrt(lens_image.Noise.C_D), origin='lower', cmap='bwr', vmin=-4, vmax=4)\n",
+    "plt.imshow((data - hybrid_image_init) / np.sqrt(true_lens_image.Noise.C_D), \n",
+    "           origin='lower', cmap=plotter.cmap_resid, vmin=-4, vmax=4)\n",
     "plt.colorbar()\n",
     "plt.show()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_pixelated_potential_result(optimizer, kwargs_f, shift_potential='min', with_mask=True):\n",
-    "    if optimizer is not None:\n",
-    "        fig, ax = plt.subplots(1, 1)\n",
-    "        ax.plot(range(len(optimizer.loss_history)), optimizer.loss_history)\n",
-    "        ax.set_ylabel(\"Loss\", fontsize=FS)\n",
-    "        ax.set_xlabel(\"Iteration\", fontsize=FS)\n",
-    "        plt.show()\n",
-    "    \n",
-    "    # create the resulting model image\n",
-    "    rec_image = hybrid_lens_image.model(**kwargs_f)\n",
-    "    noise_var = lens_image.Noise.C_D\n",
-    "    alpha_x, alpha_y = hybrid_lens_image.LensModel.alpha(x_grid_lowres, y_grid_lowres, kwargs_f['kwargs_lens'], k=1)\n",
-    "    kappa = hybrid_lens_image.LensModel.kappa(x_grid_lowres, y_grid_lowres, kwargs_f['kwargs_lens'], k=1)\n",
-    "\n",
-    "    # Reshape the final psi grid\n",
-    "    psi_grid_rec = kwargs_f['kwargs_lens'][1]['psi_grid']\n",
-    "    if shift_potential == 'min':\n",
-    "        min_in_mask = (psi_grid_rec * mask_lowres).min()\n",
-    "        psi_grid_rec = psi_grid_rec - min_in_mask\n",
-    "        print(\"delta_psi shift by min:\", min_in_mask)\n",
-    "    elif shift_potential == 'mean':\n",
-    "        mean_in_mask = (psi_grid_rec * mask_lowres).mean()\n",
-    "        true_mean_in_mask = (psi_grid_true_lowres * mask_lowres).mean()\n",
-    "        psi_grid_rec = psi_grid_rec - mean_in_mask + true_mean_in_mask\n",
-    "        print(\"delta_psi shift & normalization by mean:\", mean_in_mask, true_mean_in_mask)\n",
-    "        \n",
-    "    fig, axes = plt.subplots(3, 3, figsize=(15, 14))\n",
-    "    ax = axes[0, 0]\n",
-    "    img = ax.imshow(data, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"Data\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[0, 1]\n",
-    "    img = ax.imshow(rec_image, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"Image reconstruction\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[0, 2]\n",
-    "    img = ax.imshow((data - rec_image) / jnp.sqrt(noise_var), origin='lower', cmap='RdBu_r', vmin=-4, vmax=4, extent=extent)\n",
-    "    ax.set_title(\"Normalised residuals\", fontsize=FS)\n",
-    "    ax.set_xlabel(f\"Chi-sq : {np.mean((data - rec_image)**2 / noise_var):.2f}\")\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "\n",
-    "    ax = axes[1, 0]\n",
-    "    psi_grid_true_show = psi_grid_true_lowres\n",
-    "    if with_mask:\n",
-    "        psi_grid_true_show *= mask_lowres\n",
-    "    img = ax.imshow(psi_grid_true_show, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"True $\\delta\\psi$\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[1, 1]\n",
-    "    psi_grid_rec_show = psi_grid_rec\n",
-    "    if with_mask:\n",
-    "        psi_grid_rec_show *= mask_lowres\n",
-    "    img = ax.imshow(psi_grid_rec_show, origin='lower', extent=extent)\n",
-    "    ax.set_title(\"Reconstructed $\\delta\\psi$\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "    ax = axes[1, 2]\n",
-    "    abs_res_show = (psi_grid_true_lowres - psi_grid_rec)\n",
-    "    if with_mask:\n",
-    "        abs_res_show *= mask_lowres\n",
-    "    vmax = 0.5 * np.max(np.abs(psi_grid_true_lowres))\n",
-    "    img = ax.imshow(abs_res_show, origin='lower', cmap='RdBu_r', vmin=-vmax, vmax=vmax, extent=extent)\n",
-    "    ax.set_title(\"Absolute residuals\", fontsize=FS)\n",
-    "    fig.colorbar(img, ax=ax)\n",
-    "\n",
-    "    ax = axes[2, 0]\n",
-    "    alpha_x_rec_show = alpha_x\n",
-    "    if with_mask:\n",
-    "        alpha_x_rec_show *= mask_lowres\n",
-    "    ax.set_title(r\"$\\delta\\alpha_x$\", fontsize=FS)\n",
-    "    im = ax.imshow(alpha_x_rec_show, origin='lower', alpha=1, extent=extent)\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "    ax = axes[2, 1]\n",
-    "    alpha_y_rec_show = alpha_y\n",
-    "    if with_mask:\n",
-    "        alpha_y_rec_show *= mask_lowres\n",
-    "    ax.set_title(r\"$\\delta\\alpha_y$\", fontsize=FS)\n",
-    "    im = ax.imshow(alpha_y_rec_show, origin='lower', alpha=1, extent=extent)\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "    ax = axes[2, 2]\n",
-    "    #kappa_rec_show = kappa\n",
-    "    kappa_rec_show = ndimage.gaussian_filter(kappa, 1)\n",
-    "    if with_mask:\n",
-    "        kappa_rec_show *= mask_lowres\n",
-    "    ax.set_title(r\"$\\delta\\kappa$ (smoothed)\", fontsize=FS)\n",
-    "    im = ax.imshow(kappa_rec_show, origin='lower', cmap='inferno', alpha=1, extent=extent, vmin=0)\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "    \n",
-    "    plt.show()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -635,7 +539,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
@@ -691,15 +595,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Loss at init: 2.075332874746746\n",
-      "Loss at true: 1.198188066285599\n"
+      "Loss at initial values: 2.0897448664849727\n",
+      "Loss at true values: 1.1312525726724316\n"
      ]
     }
    ],
@@ -710,13 +614,14 @@
     "# Create loss\n",
     "loss = Loss(data, hybrid_lens_image, parameters, \n",
     "            likelihood_type='l2_norm',\n",
-    "            regularization_terms=['l1_starlet_potential', 'l1_battle_potential'], \n",
-    "            regularization_strengths=[(5, 3), 3],\n",
+    "            regularization_terms=['l1_starlet_potential', \n",
+    "                                  'l1_battle_potential'], \n",
+    "            regularization_strengths=[(3, 1), 10],\n",
     "            potential_noise_map=potential_noise_map,\n",
     "            prior_terms=None)\n",
     "\n",
-    "print(\"Loss at init:\", loss(p_init))\n",
-    "print(\"Loss at true:\", loss(p_true))"
+    "print(\"Loss at initial values:\", loss(p_init))\n",
+    "print(\"Loss at true values:\", loss(p_true))"
    ]
   },
   {
@@ -728,7 +633,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 34,
    "metadata": {
     "scrolled": false
    },
@@ -737,8 +642,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Runtime: 66.68763399124146\n",
-      "Loss at best-fit: 1.1132473653953563\n"
+      "Runtime: 39.918522119522095\n",
+      "Loss at best-fit: 1.0675865259558779\n"
      ]
     }
    ],
@@ -754,12 +659,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEOCAYAAACXX1DeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAcQUlEQVR4nO3de5xcZZ3n8c+3qrtzI+ZCN5CA3FGQ4d7CuCoTF18ScBhgZBeQGQTReBsv4zoLyijssgOLjo47oyMTFYPuTHBUhssIg4BC2BGRjhsgEO7XEKCbJJAL5NLdv/njnE6frqqudKq76lS6v+/Xq15ddc5T5zzn0J0vz3me8xxFBGZmZsMp5F0BMzNrbg4KMzOrykFhZmZVOSjMzKwqB4WZmVXVkncFxlp7e3vsu+++eVfDzGynsnTp0lcioqPSunEXFPvuuy9dXV15V8PMbKci6dnh1vnSk5mZVeWgMDOzqhwUZmZWlYPCzMyqclCYmVlVDgozM6sqt6CQdLWkbknLh1k/Q9JNku6X9JCk8xtdRzMzy7dFsQiYX2X9p4CHI+IIYB7wdUlt9arMoy+t5xu/eJRXNmyu1y7MzHZKuQVFRCwB1lQrAkyXJGCXtGxvverzRPcG/vaXT7Bm45Z67cLMbKfUzH0U3wIOAVYBDwKfjYj+SgUlLZDUJamrp6enpp0VlPzs94OczMyGaOagOBFYBswFjgS+JelNlQpGxMKI6IyIzo6OilOVbFfScIH+ilFkZjZxNXNQnA9cF4kngKeBg+u1M7cozMwqa+ageA44AUDS7sBbgafqtbNC2qJwTpiZDZXb7LGSFpOMZmqXtBK4BGgFiIirgMuARZIeBARcGBGv1Ks+hTQy3aIwMxsqt6CIiLO3s34V8L4GVWewj8JBYWY2RDNfemqowragyLkiZmZNxkGRGujMDrcozMyGcFCk3KIwM6vMQZGSh8eamVXkoEgV3JltZlaRgyLl+yjMzCpzUKR8Z7aZWWUOipTcmW1mVpGDIuUWhZlZZQ6K1GAfhYPCzCzLQZEqeJpxM7OKHBQp30dhZlaZgyI1GBT51sPMrNk4KFIDl56SR3WbmdkAB0XKcz2ZmVXmoEh5eKyZWWUOipRvuDMzq8xBkfLzKMzMKnNQpDx7rJlZZQ6KlG+4MzOrLLegkHS1pG5Jy4dZ/xeSlqWv5ZL6JM2uX32Sn25RmJkNlWeLYhEwf7iVEfG1iDgyIo4EvgjcFRFr6lWZQsHPozAzqyS3oIiIJcBI/+E/G1hcx+p4eKyZ2TCavo9C0lSSlsfPqpRZIKlLUldPT09N+/ENd2ZmlTV9UACnAP9e7bJTRCyMiM6I6Ozo6KhpJ+6jMDOrbGcIirOo82Un8PMozMyG09RBIWkG8AfADfXely89mZlV1pLXjiUtBuYB7ZJWApcArQARcVVa7HTgFxGxsd71cWe2mVlluQVFRJw9gjKLSIbR1p3nejIzq6ypLz01kud6MjOrzEGRkud6MjOryEGRKvhRqGZmFTkoUoPDY3OuiJlZk3FQpHzDnZlZZQ6KlG+4MzOrzEGR8g13ZmaVOShSvuHOzKwyB0XKN9yZmVXmoMgoyH0UZmalHBQZBcmXnszMSjgoMpKgyLsWZmbNxUGRIbkz28yslIMioyD5zmwzsxIOioyCoN/XnszMhnBQZLiPwsysnIMiw30UZmblHBQZhYJ8H4WZWQkHRYYvPZmZlcstKCRdLalb0vIqZeZJWibpIUl31btOBV96MjMrk2eLYhEwf7iVkmYCfw/8UUQcCvyX+lfJLQozs1K5BUVELAHWVCnyQeC6iHguLd9d7zp5riczs3LN3EfxFmCWpDslLZV07nAFJS2Q1CWpq6enp+Yd+oY7M7NyzRwULcAxwPuBE4EvS3pLpYIRsTAiOiOis6Ojo+Yduo/CzKxcS94VqGIlsDoiNgIbJS0BjgAeq9cO5VFPZmZlmrlFcQPwLkktkqYCxwEr6rnDQsF9FGZmpXJrUUhaDMwD2iWtBC4BWgEi4qqIWCHp34AHgH7gexEx7FDaseDnUZiZlcstKCLi7BGU+RrwtQZUB/ANd2ZmlTTzpaeG81xPZmblHBQZHh5rZlbOQZHh4bFmZuUcFBnuzDYzK+egyPB9FGZm5RwUGZ7rycysnIMiw8NjzczKOSgy3JltZlbOQZHhPgozs3IOigz3UZiZlXNQZHh4rJlZOQdFRkGivz/vWpiZNRcHRZY7s83MyjgoMgoCx4SZ2VAOioxkUkBHhZlZloMiwzfcmZmVc1Bk+HkUZmblHBQZblGYmZVzUGT4hjszs3IOigzfcGdmVm5MgkJSi6QPSPqopD1G+J2rJXVLWj7M+nmSXpO0LH19ZSzqup06+YY7M7MSOxwUkr4q6b7MZwG3A/8M/APwoKQDRrCpRcD87ZS5OyKOTF//c0fruqM8e6yZWblaWhTzgbszn08Bjge+BnwwXXbR9jYSEUuANTXsv26S+yjyroWZWXNpqeE7bwYez3w+BXg6Ii4CkHQocM4Y1A3gHZLuB1YBX4iIhyoVkrQAWACw995717yzQgH6nBRmZkPU0qJoA3ozn99DculpwFPAnNFUKvU7YJ+IOAL4O+D64QpGxMKI6IyIzo6Ojpp36M5sM7NytQTF88A7YFvrYX/grsz63YANo61YRKyLiA3p+5uBVknto91uNS0F0ecbKczMhqjl0tO1wJcl7QYcCqwDbs6sPwp4crQVS0dPvRwRIelYklBbPdrtVlMsFOjtc1CYmWXVEhRXkPRTnAa8BpwbEa8CSJoB/BHwN9vbiKTFwDygXdJK4BKgFSAirgLOAD4hqRd4Azgr6nw3nFsUZmbldjgoImIzcEH6KrWepH/i9RFs5+ztrP8W8K0drd9oFIui10FhZjZELS2Kaloj4rUx3mbDJC0K33FnZpZVyw13J0m6tGTZJyWtAzZK+idJrWNVwUYqFtyiMDMrVcuop78ADh74IOkQ4P+Q3OtwG3Am8KkxqV2DuY/CzKxcLUFxCNCV+XwmSWfzsRFxEvBj4ENjULeGKxYKblGYmZWoJShmAa9kPr8X+GVErEs/3wnsN8p65cItCjOzcrUExSvAPgCSpgNvZ+jcT61AcfRVa7xiGhR+JoWZ2aBaRj3dA3xc0kPASek2bsmsPxB4cQzq1nAtBQHQ1x+0FJVzbczMmkMtQXEJ8CuSacUBromIh2HblOOnp+t3OsU0HHr7g5adsk1kZjb2arnh7uF0pNM7gdfS6cIHzCS5K/vOMaldg2VbFGZmlqjphruIWAPcVGH5WpKhsjulYiHpsvHIJzOzQTXfmZ0+xe5UktljIZle/IaIGPWEgHlxi8LMrFxNQSHpMpKn2JVeyf+qpMsjou7Pt66HYmGgj8LTeJiZDahlCo8PAxcD95LMIHtQ+jqNZETUxZLOG7MaNpBbFGZm5WppUXyKJCTmRUT2SXdPSrqZ5J6KTwOLRl+9xtrWovAzKczMtql1Co9rS0ICgHTZtWmZnc7AvRNuUZiZDaolKLYAu1RZPz0ts9PxqCczs3K1BMV9wMck7V66In086gKSS1M7HfdRmJmVq6WP4jLgDmCFpO8DD6fLDwXOJ2lRnDM21Wssj3oyMytXy53ZSyT9McljSv9byernSJ6hfXf5N5ufWxRmZuVqufRERNxEMpX4ccBZ6etYkpvv9pL0cJWvN63BFoWDwsxsQE1BARAR/RFxX0T8c/rqioh+oB146/a+L+lqSd2Slm+n3Nsl9Uo6o9a6jlRL2pntFoWZ2aCag2IMLALmVysgqQhcCfyiERXyfRRmZuVyC4p01tk12yn2aeBnQHf9a+T7KMzMKsmzRVGVpD1Jnm3xnRGUXSCpS1JXT09Pzfv0qCczs3JNGxTAN4EL036PqiJiYUR0RkRnR0dHzTv0qCczs3IjGh4r6fM7sM131liXUp3AtclD82gHTpbUGxHXj9H2y3jUk5lZuZHeR/HXO7jdUf9LGxH7DbyXtAj413qGBHjUk5lZJSMNiveM9Y4lLQbmAe2SVpI8i7sVICKuGuv9jYRbFGZm5UYUFBFx11jvOCLO3oGy5431/isZ7KNwZ7aZ2YBm7sxuuIHhsVt73aIwMxvgoMhoa0lOx5Y+tyjMzAY4KDLaimlQ9DoozMwGOCgy3KIwMyvnoMhwi8LMrJyDIqNYEBJsdYvCzGwbB0WGJNqKBbcozMwyHBQl2loKbHZQmJlt46Ao0VYs+NKTmVmGg6JEW4svPZmZZTkoSrS1FDw81swsw0FRotWXnszMhnBQlPCoJzOzoRwUJTzqycxsKAdFCY96MjMbykFRwi0KM7OhHBQlJrcW2bTVQWFmNsBBUWJqW5FNW/vyroaZWdNwUJSY0lrkjS0OCjOzAbkFhaSrJXVLWj7M+lMlPSBpmaQuSe9qRL2mtBV5wy0KM7Nt8mxRLALmV1l/B3BERBwJfBj4XgPqxGS3KMzMhsgtKCJiCbCmyvoNERHpx2lADFd2LE1pLbKlr59eD5E1MwOavI9C0umSHgF+TtKqGK7cgvTyVFdPT8+o9jmlLTklmzxE1swMaPKgiIh/iYiDgdOAy6qUWxgRnRHR2dHRMap9TmktAvjyk5lZqqmDYkB6mWp/Se313tfkNCg8RNbMLNG0QSHpQElK3x8NTAJW13u/U9rSFoWDwswMgJa8dixpMTAPaJe0ErgEaAWIiKuADwDnStoKvAGcmencrhtfejIzGyq3oIiIs7ez/krgygZVZ5ttQeEWhZkZ0MSXnvIy2ZeezMyGcFCUmD4paWSte2NrzjUxM2sODooSs6e1AbB245aca2Jm1hwcFCVmTGlFgjWvu0VhZgYOijItxQIzprS6RWFmlnJQVDB7ahtrXndQmJmBg6KiWdPaWLPBQWFmBg6KimZPa2OtWxRmZoCDoqLZU9tY4z4KMzPAQVHRrLRF0YAZQ8zMmp6DooLZ01rZ2hds2Nybd1XMzHLnoKhg1tTkpjtffjIzc1BUtOsuSVCsdlCYmTkoKtlt+mQAutdtzrkmZmb5c1BUMGdGEhSrXn0j55qYmeXPQVHB7GltTGop8OJrDgozMwdFBZKYO3MKq17dlHdVzMxy56AYxpwZk1nlFoWZmYNiOHNnTuGFtQ4KMzMHxTD2a59G9/rNrN/k51KY2cSWW1BIulpSt6Tlw6w/R9IDkh6U9GtJRzSyfm/ZfToAT3RvaORuzcyaTp4tikXA/Crrnwb+ICIOAy4DFjaiUgMO2m0XAB5/2UFhZhNbbkEREUuANVXW/zoi1qYffwPs1ZCKpfaePZXpk1q4f+WrjdytmVnT2Vn6KC4AbhlupaQFkrokdfX09IzJDgsFceTeM1n67NrtFzYzG8eaPigkvYckKC4crkxELIyIzojo7OjoGLN9H7vvbB59eT3d63w/hZlNXE0dFJIOB74HnBoRqxu9/xN/bw8i4JblLzV612ZmTaNpg0LS3sB1wJ9GxGN51OEtu0/noN124ecPvpjH7s3MmkKew2MXA/cAb5W0UtIFkj4u6eNpka8AuwJ/L2mZpK486vn+w+dw3zNrfPnJzCaslrx2HBFnb2f9R4CPNKg6w/rDw+fwzdsf58b7V/GRd++fd3XMzBquaS89NYsDd5tO5z6z+O7dT/Ha675L28wmHgfFCFxyyqGs3rCFr9xY8SZyM7NxzUExAoftNYPPnHAQNyxbxeLfPpd3dczMGspBMUKfnHcA7z6onS9e9yBX3LyCzb19eVfJzKwhHBQj1FIs8N1zO/ngcXvzD0ue4qRv3s1Pl67k9S29eVfNzKyuFBF512FMdXZ2RldXfUfS/urRbq685REeeWk9bS0F/tMBu3LCwbtxwiG7M3fmlLru28ysHiQtjYjOiuscFLWJCO55ajW3P9zNLx95mWdWvw7AIXPexHsPSULj8D1nUCio7nUxMxstB0WdRQRP9mzkjhUvc8eKbrqeXUN/QPsuk/jAMXvyseMPYPa0tobWycxsRzgoGmztxi3c+Vg3ty5/mVsffomprUX+6vTDOO2oPXOtl5nZcKoFRW53Zo9ns6a1cfpRe3H6UXvxRPd6vnTdcj7342X87rm1XPz+Q5jUUsy7imZmI+ZRT3V24G7T+cePHseC4/fnh/c8y598715ee8N3eJvZzsNB0QCtxQJfOvkQ/u7so1j2/Kuc/u1/596nGj5ruplZTRwUDXTKEXP5vxccx+befs5c+Bu+8JP7Wb1hc97VMjOrykHRYMftvyu3ff54PjHvAK7//y/wn79+F9f+9jn6+8fXoAIzGz8cFDmY2tbChfMP5ubPvpu37jGdi657kDOu+jV3PdZDnwPDzJqMh8fmLCL42e9e4IqbV7B64xY6pk/iuP1m07nPLI7ZZzaHzJlOS9F5bmb15eGxTUwSZxyzF6ccMYdfrujm5uUvsfSZNfzrA8njV6e2FTl07pvYa9ZU5syYzNyZU5gzYzLTJrUwpbXIlLYiU1qLTE7fT24pOFjMbEw5KJrEpJYiJx02h5MOmwPAqlffYOmza1n67FoeWvUav316DS+v20TvCC5NFZRsr62lQFtLgUnbfibLJhULTGot0FasvD67rK1YYFJrscJ3Bssmy0RbsUhri7aVKRaEEEpnMZHY9llAQel7eZoTs2bmoGhSc2dOYe7MKZxyxNxty/r6g571m3lp3SZe39zLG1v7kteWPjal7zdt7WdLbz+be/vY0tvPlr5+Nm/tZ3PfwPJ+tvT2sXFzL2t6+4eU2dI3+N2tfY2/JDkQIJLSn5lgKQmZgTJkPme3s+192T5Ucd3QrBr6reG2V5pvYvt1qBaKQ74zBtse7pAmWixPpP8ROevtb67LI5sdFDuRYkHsMWMye8yYXPd99fdHEiBDwqQvEybp8oH3ff1s7R0Mmy29/fRFEAFB8hOSPplkGURAfwSRrNi2bKB82eeovDwr2+dWGnXZspFZO3T58N9hmO+Mxbaz3yktmP043PGV1WcE35kQJtgBt+8yqS7bzS0oJF0N/CHQHRG/V2H9wcAPgKOBiyPirxtcxQmtUBCTC0nfh5lNbHn2ei4C5ldZvwb4DOCAMDPLUW5BERFLSMJguPXdEXEf4ImRzMxyNC7GUUpaIKlLUldPT0/e1TEzG1fGRVBExMKI6IyIzo6OjryrY2Y2royLoDAzs/pxUJiZWVV5Do9dDMwD2iWtBC4BWgEi4ipJewBdwJuAfkmfA94WEevyqbGZ2cSUW1BExNnbWf8SsFeDqmNmZsMYd7PHSuoBnq3x6+3AK2NYnZ2Zz8Ugn4tBPheDxtu52CciKo4GGndBMRqSuoabZnei8bkY5HMxyOdi0EQ6F+7MNjOzqhwUZmZWlYNiqIV5V6CJ+FwM8rkY5HMxaMKcC/dRmJlZVW5RmJlZVQ4KMzOrykGRkjRf0qOSnpB0Ud71aQRJz0h6UNIySV3pstmSbpP0ePpzVrpckv42PT8PSDo639qPjqSrJXVLWp5ZtsPHLulDafnHJX0oj2MZrWHOxaWSXkh/N5ZJOjmz7ovpuXhU0omZ5Tv135CkN0v6laSHJT0k6bPp8gn5ezFE8njJif0CisCTwP5AG3A/yXQhudetzsf9DNBesuyrwEXp+4uAK9P3JwO3kDxy+feBe/Ou/yiP/XiSpycur/XYgdnAU+nPWen7WXkf2xidi0uBL1Qo+7b072MSsF/6d1McD39DwBzg6PT9dOCx9Hgn5O9F9uUWReJY4ImIeCoitgDXAqfmXKe8nApck76/Bjgts/yHkfgNMFPSnBzqNyai8oOzdvTYTwRui4g1EbEWuI3qT21sSsOci+GcClwbEZsj4mngCZK/n53+bygiXoyI36Xv1wMrgD2ZoL8XWQ6KxJ7A85nPK9Nl410Av5C0VNKCdNnuEfFi+v4lYPf0/UQ4Rzt67OP9nPxZeknl6oHLLUyQcyFpX+Ao4F78e+GgmODeFRFHAycBn5J0fHZlJO3oCTl+eiIfe+o7wAHAkcCLwNdzrU0DSdoF+BnwuSiZrXqi/l44KBIvAG/OfN4rXTauRcQL6c9u4F9ILh+8PHBJKf3ZnRafCOdoR4993J6TiHg5Ivoioh/4LsnvBozzcyGplSQk/jEirksXT/jfCwdF4j7gIEn7SWoDzgJuzLlOdSVpmqTpA++B9wHLSY57YJTGh4Ab0vc3AuemIz1+H3gt0xwfL3b02G8F3idpVnpp5n3psp1eSf/T6SS/G5Cci7MkTZK0H3AQ8FvGwd+QJAHfB1ZExDcyq/x7kXdverO8SEYwPEYycuPivOvTgOPdn2Rkyv3AQwPHDOwK3AE8DtwOzE6XC/h2en4eBDrzPoZRHv9ikksqW0muIV9Qy7EDHybp0H0COD/v4xrDc/Gj9FgfIPkHcU6m/MXpuXgUOCmzfKf+GwLeRXJZ6QFgWfo6eaL+XmRfnsLDzMyq8qUnMzOrykFhZmZVOSjMzKwqB4WZmVXloDAzs6ocFGZNStI8SSHpvLzrYhObg8LGrcw/tF9IP89Mp8+el2/NBkk6Mq3TvnnXxWw4LXlXwKyBZgKXpO/vzK8aQxxJUqc7SaZ9z1oCTCG5Ec4sN25RmI2RgSlRxkpE9EfEpojoG8vtmu0oB4VNCOnlpqfTj5ekl6RC0jMl5c6U9P8krZf0uqR7JZ1RYXshaZGkE9LyG4Cb0nVzJX09fTLcWkmb0qemXSipmNnGpcAP0o+/ytRp0UCdK/VRpPN0XSHpSUmbJb0k6YeS9ik95oHvSzo/fWrbZknPSvrvNZ9Mm3B86ckmihXAnwN/QzJT7sDMoBsGCkj6XyTzGP0b8GWgn2RCvJ9I+rOI+HbJNjuBD5DMrnpNZvnhwB+n+3kSaCV5cM3/Jplj62NpuetInqq2ALg8rSPpdypKZze9FXgn8FOS6b8PAj5BMhFdZ0SsLPnax0meofB94FXgT4ArJa2MiH8abl9m2+Q92ZRfftXrBcwjmeTtC+nnfdPPl1Yoe3S67vIK664H1gHTM8sGnkvw3grlp0Ayj1rJ8h8BfQydYO+8dDvzqtT/vMyyj6bLvlpS9v3p8h9V+P4qYEZm+VSgB7gn7/9Gfu0cL196MkucQ/KP6jWS2rMvktlTpwPvKPnO/RFxe+mGIuKNiEimF5XaJM1Ot3MryeXezlHU83SSls4VJfv8Oclsp6dKKv27/kFEvJYp+zrwG5KWiNl2+dKTWeIQkmmjH6lSZveSz49VKiSpBbgIOBc4MN1u1qyyL43cfsCqSJ7FXOohklFU7Qw+XAfgqQplV5NMn222XQ4Ks4RIWhQnkVwequShks+vD1PuG8CngR8Df0Xyj/ZWkstbV9L4QSQeNWWj4qCwiaTaw1ceJ+lwfi4iVlQpNxJ/CiyJiLOyCyUduIN1quQpYL6kmRHxasm6t5H0pbyyg9s0q8p9FDaRDIxwml1h3Y/Sn5dnh7AOkFR62amaPkouN6WPm/3zHaxTJdeT/N1eVLL9k4CjgBsjec612Zhxi8ImjIhYLekJkmc+Pwm8DGyMiJsi4r70voZLgWWSfkIyWmgOcAzJIzHbRrirnwIfk/Rjkkdn7k7yaMzVFcreR9I5fXH6fOWNwNMRce8w215E8tzmC9NpP5aQ9IN8Mj2eL42wjmYj5qCwieYcknspLicZJvos6Y1yEfE/JHUBnwE+B0wj6V9Yni4bqc8D64H/CpwKPA8sJAmFIaOkIuI5SR8GLgS+Q3LPxTVAxaCIiK2STgT+EjiT5H6NV4GfAH8ZEc/vQD3NRsTPzDYzs6rcR2FmZlU5KMzMrCoHhZmZVeWgMDOzqhwUZmZWlYPCzMyqclCYmVlVDgozM6vKQWFmZlX9B84MS8v2r/dgAAAAAElFTkSuQmCC\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEOCAYAAACXX1DeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAgz0lEQVR4nO3deXwdd33u8c9zztFi2fIWyWsWJyRxFiBLBSQNpWYpJECztNxLUiiE5aZQSveWQFpCLy29AVpoL9DUlwanlJo1JIRCoUDAtIEQhTqJszhxdsd2JK/ybi3f+8eM5JF0dCzJOmeO7ef9ep2Xziya+Xrko0e/+c38RhGBmZnZWAp5F2BmZvXNQWFmZhU5KMzMrCIHhZmZVeSgMDOzikp5FzDV2traYsmSJXmXYWZ2RLnnnns2R0R7uWVHXVAsWbKEzs7OvMswMzuiSHpqrGU+9WRmZhU5KMzMrCIHhZmZVeSgMDOzihwUZmZWkYPCzMwqclCYmVlFDorU2k07+dvvrmXzrv15l2JmVlccFKl1Xbv4+x+sY+vuA3mXYmZWVxwUKSn5OuAHOZmZDeOgSBXSoHBOmJkN56BIKW1SuEVhZjacgyKVNijcojAzG8FBkSqkLQoHhZnZcA6KlDuzzczKc1CkhloUOddhZlZvcgsKSTdJ6pK0ZozlsyTdLuleSQ9Ielt160m+ukVhZjZcni2KFcDFFZa/B3gwIs4BlgF/I6mxWsVoqI/CQWFmlpVbUETEKmBrpVWAViW/wWek6/ZVqx7fR2FmVl4991F8CjgT2ADcD/xeRAyUW1HSNZI6JXV2d3dPamdi8D6KyRVrZna0quegeA2wGlgEnAt8StLMcitGxPKI6IiIjvb29knt7GCLwklhZpZVz0HxNuCWSKwDngDOqNbODt6ZXa09mJkdmeo5KJ4GXgkgaT6wFHi8WjuTWxRmZmWV8tqxpJUkVzO1SVoPXA80AETEjcCHgRWS7icZYeN9EbG5WvX4Pgozs/JyC4qIuOoQyzcAr65ROb6PwsxsDPV86qmmfHmsmVl5DoqUhxk3MyvPQZHyMONmZuU5KFIHO7OdFGZmWQ6K1FBndtl7v83Mjl0OipQvjzUzK89BMYI7s83MhnNQpPwoVDOz8hwUqUJ6JDyEh5nZcA6KlIcZNzMrz0GRGroz293ZZmbDOChSB8d6yrcOM7N646BI+ZnZZmblOShSxTQo+t2kMDMbxkGRaiwlh+JAn2/NNjPLclCkhoKi30FhZpbloEg1uUVhZlZWbkEh6SZJXZLWjLH8TyStTl9rJPVLmlutegZbFPsdFGZmw+TZolgBXDzWwoj4WEScGxHnAu8HfhQRW6tVTGPRQWFmVk5uQRERq4Dx/uK/ClhZxXKQRGOpwP6+/mruxszsiFP3fRSSWkhaHl+rsM41kjoldXZ3d096X02lgvsozMxGqPugAH4V+K9Kp50iYnlEdERER3t7+6R35KAwMxvtSAiKK6nyaadBTaWi+yjMzEao66CQNAv4ZeC2Wuyv0S0KM7NRSnntWNJKYBnQJmk9cD3QABARN6arXQF8NyJ216KmxqKDwsxspNyCIiKuGsc6K0guo62JpgZf9WRmNlJdn3qqtYZiwUN4mJmN4KDIKBXk0WPNzEZwUGSUig4KM7ORHBQZxUKBPgeFmdkwDooMn3oyMxvNQZFRLIi+fgeFmVmWgyLDLQozs9EcFBnFgugd8OWxZmZZDooMtyjMzEZzUGQUCwX3UZiZjeCgyHCLwsxsNAdFRqko30dhZjaCgyIjaVG4M9vMLMtBkeE7s83MRnNQZHisJzOz0RwUGcWC+yjMzEbKLSgk3SSpS9KaCussk7Ra0gOSflTtmnzVk5nZaHm2KFYAF4+1UNJs4DPApRFxNvA/ql1QMQ2KCIeFmdmg3IIiIlYBWyus8hvALRHxdLp+V7VrKhUE4NNPZmYZ9dxHcTowR9IPJd0j6S1jrSjpGkmdkjq7u7snvcNiITkcPv1kZnZQPQdFCfgF4HXAa4A/l3R6uRUjYnlEdERER3t7++R36BaFmdkopbwLqGA9sCUidgO7Ja0CzgEeqdYOi2lQ9Hu8JzOzIfXcorgNeKmkkqQW4CXAQ9XcYUNxsEXhu7PNzAbl1qKQtBJYBrRJWg9cDzQARMSNEfGQpH8H7gMGgM9GxJiX0k4F91GYmY2WW1BExFXjWOdjwMdqUA7gPgozs3Lq+dRTzQ31UTgozMyGOCgySkW3KMzMRnJQZAy2KPr63ZltZjbIQZHhPgozs9EcFBm+6snMbDQHRYZbFGZmozkoMg5e9eQ+CjOzQQ6KjKEWhYfwMDMb4qDI8H0UZmajOSgySsXkcLiPwszsIAdFRsktCjOzURwUGUVf9WRmNoqDImNoCA/fmW1mNsRBkeH7KMzMRnNQZPjObDOz0RwUGW5RmJmNNiUPLpJUAi4D5gK3R8SmqdhurfnObDOz0SbcopD0UUl3Z6YFfA/4MvCPwP2SnjeO7dwkqUtS2cebSlomaYek1enrgxOtdaLcojAzG20yp54uBn6cmf5V4GUkjyz9jXTetePYzop0W5X8OCLOTV//e6KFTpTvzDYzG20yp55OAB7NTP8q8EREXAsg6WzgTYfaSESskrRkEvuvmlLame2xnszMDppMi6IR6MtMv5zk1NOgx4GFh1NUxoWS7pX07TSAypJ0jaROSZ3d3d2T3lmx6BaFmdlIkwmKZ4ALYaj1cArwo8zyecCuwy+NnwMnRcQ5wP8Fbh1rxYhYHhEdEdHR3t4+6R26j8LMbLTJBMUXgbdK+ibwTaAH+FZm+XnAY4dbWET0RMSu9P23gAZJbYe73UpKfma2mdkokwmKvybpiL4QCOAtEbEdQNIs4FLg+4dbmKQF6RVVSHpxWuuWw91uJR7rycxstAl3ZkfEfuAd6WuknST9E3sOtR1JK4FlQJuk9cD1QEO6jxuBNwDvltQH7AWujIiq/gaXRLEg91GYmWVMyQ13GQ0RsWM8K0bEVYdY/ingU1NS1QQUC3KLwswsYzI33F0i6UMj5v22pB5gt6R/ldQwVQXWWqkg35ltZpYxmT6KPwHOGJyQdCbwd8AG4D+ANwLvmZLqcuAWhZnZcJMJijOBzsz0G0n6EF4cEZcAXwLeOgW15aLkPgozs2EmExRzgM2Z6VcBP4iInnT6h8DJh1lXboqFglsUZmYZkwmKzcBJAJJagRcxfOynBqB4+KXlo1QQ/R7Cw8xsyGSuevoJ8C5JDwCXpNv4dmb5qcDGKagtF+6jMDMbbjJBcT1wB8mw4gA3R8SDMDTk+BXp8iNSqSj6fNWTmdmQydxw92B6pdNFwI6IWJVZPBv4BEk/xRGp5BaFmdkwk7rhLiK2AreXmb+N5FLZI1apUHAfhZlZxqTvzE6fYncZyeixkAwvfltEHPaAgHlyH4WZ2XCTCgpJHyZ5it3Iq5s+KukjEVH1x5ZWS6noO7PNzLImM4TH24HrgLuAy4HT0tflJFdEXSfp6imrsMbcojAzG24yLYr3kITEsojIPunuMUnfIrmn4r0kQ5EfcXxntpnZcJMdwuOLI0ICgHTeF9N1jkhuUZiZDTeZoDgAzKiwvDVd54hUKhTcojAzy5hMUNwN/Jak+SMXSJoHXENyauqI5BaFmdlwkwmKD5M8xe4hSR+T9Lb09XHgIWAB8JeH2oikmyR1SVpziPVeJKlP0hsmUeuElQryM7PNzDImc2f2Kkm/RvL0uT8asfhpkmdo/3j0d46yIt3GP4+1gqQicAPw3YnWOVl+FKqZ2XCTaVEQEbeTDCX+EuDK9PVikpvvjpf04Di2sQrYeojV3gt8DeiaTJ2T0VD0MONmZlmTvjM7IgZI+ivuzs6X1AYsPcy6kLSYZIDBl5MMZV5p3WtI+kY48cQTD2u/paLo9aknM7Mhk2pR1MgngfelgVRRRCyPiI6I6Ghvbz+snTaVChzoc1CYmQ2adIuiBjqALyYjl9MGvFZSX0TcWs2dNpWK7HdQmJkNqdugiIihx6lKWgF8s9ohAUmLYn9vf7V3Y2Z2xMgtKCStBJYBbZLWkzwQqQEgIm7Mq66mhoJbFGZmGeMKCkl/OIFtXjSelSLiqvFuMCKunsD+D0tTqUjfQNDXP0CpWM9dOGZmtTHeFsXHJ7jdI/b60qZSEg4HHBRmZsD4g+LlVa2ijgwGxb7eAVoacy7GzKwOjCsoIuJH1S6kXjQ1JM9i2t/nDm0zM6jv+yhyMdii2N/rDm0zM3BQjNJUGmxROCjMzMBBMcpQi8KnnszMAAfFKE0Ng0HhFoWZGTgoRhk69eQ+CjMzwEExik89mZkN56AYwaeezMyGc1CM0FzyfRRmZlkOihGGWhTuozAzAxwUowy2KPYccIvCzAwcFKO0NA0GRV/OlZiZ1QcHxQhNpSINRbHbLQozM8BBUVZLY4k9+92iMDMDB0VZ0xuL7NrvFoWZGeQYFJJuktQlac0Yyy+TdJ+k1ZI6Jb20VrVNbyq5j8LMLJVni2IFcHGF5d8HzomIc4G3A5+tQU0AtDSV3EdhZpbKLSgiYhWwtcLyXREx+EjV6dTw8arTG4vsdh+FmRlQ530Ukq6Q9DDwbyStirHWuyY9PdXZ3d192Pud3lRyUJiZpeo6KCLi6xFxBnA58OEK6y2PiI6I6Ghvbz/s/U5vLPqGOzOzVF0HxaD0NNUpktpqsb8WtyjMzIbUbVBIOlWS0vfnA03AllrsO7k81kFhZgZQymvHklYCy4A2SeuB64EGgIi4Efh14C2SeoG9wBszndtVNbulkf19A+zr7ae5oViLXZqZ1a3cgiIirjrE8huAG2pUzjCzWxoA2L6nlwWzHBRmdmyr21NPeZrb0gjA1t0Hcq7EzCx/DooyZqdBsX2Pg8LMzEFRxtzpaYvCQWFm5qAoZ8GsZgA2bt+XcyVmZvlzUJQxa1oDrc0l1m/bk3cpZma5c1CM4fg5LazftjfvMszMcuegGMPxc6Y5KMzMcFCMafHsaazftoca3eNnZla3HBRjOH7ONHYf6Gfbnt68SzEzy5WDYgynzW8FYO2mnTlXYmaWLwfFGM5ckATFw5t6cq7EzCxfDooxtLc2cdz0Rh7c4KAws2Obg2IMkjjvxNl0PrUt71LMzHLloKjgJScfxxObd9PV4zu0zezY5aCo4CWnzAXgp09szbkSM7P8OCgqOGvhTFqbSvzno915l2JmlpvcgkLSTZK6JK0ZY/mbJN0n6X5Jd0o6p9Y1looFfuXs+Xx7zSb29fbXevdmZnUhzxbFCuDiCsufAH45Il4AfBhYXouiRrrivMXs3NfHD9d25bF7M7Pc5RYUEbEKGPPkf0TcGRGDlxz9FDi+JoWN8IvPa6O9tYmv//ezeezezCx3R0ofxTuAb4+1UNI1kjoldXZ3T21/QrEgLj1nEXc83O0n3pnZManug0LSy0mC4n1jrRMRyyOiIyI62tvbp7yGK85bzIH+Af7t/o1Tvm0zs3pX10Eh6YXAZ4HLImJLXnWcvWgmS+e3cvOdTzIw4NFkzezYUrdBIelE4BbgNyPikZxr4T2vOJVHntvlVoWZHXPyvDx2JfATYKmk9ZLeIeldkt6VrvJB4DjgM5JWS+rMq1aA171gIafNm8EnvvcIB/oG8izFzKymSnntOCKuOsTydwLvrFE5h1QsiGsvOYN33NzJ8lWP8TuvOC3vkszMaqJuTz3Vo1eeOZ/XvWAhf/+DdTzevSvvcszMasJBMUHXX3oWTaUCH/j6/X5MqpkdExwUEzSvtZkPvPZMfvr4Vlb+7Jm8yzEzqzoHxSS8seMEXnpqG39x+wOseXZH3uWYmVWVg2ISCgXxySvPpW1GE++4+W6e3b4375LMzKrGQTFJbTOauOnqF7Fnfz9XLv8Jz2zdk3dJZmZV4aA4DEsXtPIv73wJPXv7uOIzd/Lt+ze6g9vMjjoOisN0zgmz+cq7LmReaxPv/sLPufwzd/LdBzZ5qA8zO2o4KKbA6fNbue13LuKvrng+W3fv55rP38Mlf/djblv9LH39vovbzI5sOtpOlXR0dERnZ36jffT1D3D7fRv4zB2P8WjXLk46roV3/fLz+LXzF9NUKuZWl5lZJZLuiYiOssscFNUxMBD8x0PP8ek71nHf+h0smNnMlS8+gcvPXcyStul5l2dmNoyDIkcRwX+t28KNP3qM/3psMxFJv8bl5y7i9S9cRHtrU94lmpk5KOrFxh17uf3eDdz63xt4cGMPxYK46NQ2Xv/ChVxw8nGcMHcakvIu08yOQQ6KOvToczu5dfWz3LZ6A+u3JTfstbc2cf6JszljwUzOWNDKafNnsHh2C9Ma3bdhZtXloKhjEcHa53bS+eQ27nlqG6uf2c6TW3aT/bHMnd7IotnNLJ49jUWzp7E4fS2aPY3Fc6Yxt6WRQsEtETObvEpBkdvzKCwhKW1BzOTNF5wEwN4D/azr2sVj3bt4dvtent2+lw3b9/J4925+/Ohm9hzoH7aNgmBGU4mZ0xqY2dxAa/PB9zOnlWhtbmDm0LxSOr+BWdMamDezyVdjmVlFDoo6NK2xyAuOn8ULjp81allE0LO3j/Xb97Bh+z6e3baHrbsP0LOvj559vfTsTb4+s3UPO9N5O/f1VdzfnJYG5s9sZt7MZua3NjF/ZjPzZzYxb2YzC2Y2s3BWM20zmtxqMTtG5RYUkm4CXg90RcTzyyw/A/gccD5wXUR8vMYl1iVJzGppYFbLLM5eNDpIyukfCHbt76Nnb+9QePTs7WXr7gN07dxP1859PNezn66efTyyaSfdu/bTP+LO8lJBzE9DY8GsZhbNnsap82awdH7Sl9LS6L85zI5WeX66VwCfAv55jOVbgd8FLq9RPUetYkHMSk81jUf/QLBl936e27GfTT372LRjLxt37GPTjn1s3LGPBzb08N0Hnxt6drgEJ81t4cLntfGqM+dx0altNDf4dJbZ0SLPZ2avkrSkwvIuoEvS62pXlUESLPNam5nX2swLKN9q6R8Int66h7WbdrJ2007WbNjBN1Y/y8qfPU1zQ4Flp8/jj1+zlFPnzahx9WY21Y6K8wWSrgGuATjxxBNzrubYUCyIk9umc3LbdC5+/gIA9vf1c9fjW/nBw13c8vP1XP7pzXz2rR1ccMpxOVdrZofjqBgUMCKWR0RHRHS0t7fnXc4xq6lU5GWnt/OhS8/mO3/wMubNbOLNn72Lm+98Mu/SzOwwHBVBYfVn4axpfP3dF7Fs6Tyu/8YDfPC2NWzc4ScBmh2JjopTT1afZrU0cOObz+evvvUQK+58kn/56VM8f/Eszj9xDr9w0hzOXjSTk46bTtGX3ZrVtdzuzJa0ElgGtAHPAdcDDQARcaOkBUAnMBMYAHYBZ0VET6XtHml3Zh8rntm6h6/9fD0/fXwLq5/Zzr7e5Iqp5oYCS+e3snRB69DQJUsXtHLcDA+WaFZLHsLD6kpv/wBrN+3koY09PLxpJw9v6uHhjTvZsvvA0DptMxpZuqCV0+e38rz2GUMd5wtmNvvGP7Mq8BAeVlcaigWev3gWz188/NLb7p37eXhTD2s37eSR55LLbr/4s2fY23twyJKmUoHj50xjdkvj0L0hLY1FpjUUaW4oMq2xSFOpwLTGIs2lZLq5oUBjsUipKEoFUSyIUqGQfE3nlQoFisOWJ18lIZJ7RYQYHNx36Gs6L1kns65HAbajiIPC6kZ7axPtre380mkHr1wbGAg29ezjyc27eWLLbp7cvJv12/bSs6+Xrp37eLRrJ3sP9Cev3n7q7VHl2RABhoUOYlQIZQNn8BuG5pUJJDLfxxjbGpo/YhlUN9CqHpVV3EG1a6/Wcb/yRSfwzl86Zcq366CwulYoiEXpSLm/eGpbxXUjgt7+YG9vP/t7k+DY25uESG9/0DcwQP9A0DcQ9KfTfQORzOuPoWV9AwND00EQAQHp1xg2sm9E+eWRLByaD5TdFkPTw5dl1x/aT5l9JMsjXaf88lH7Gar9sH40FVU7r6t5yrzqf2tUcQdtVerbc1DYUUMSjSXRWCrAOIcrMbND830UZmZWkYPCzMwqclCYmVlFDgozM6vIQWFmZhU5KMzMrCIHhZmZVeSgMDOzio66QQEldQNPTfLb24DNU1jOVKnHulzT+NVjXa5p/OqxrmrUdFJElH3y21EXFIdDUudYoyfmqR7rck3jV491uabxq8e6al2TTz2ZmVlFDgozM6vIQTHc8rwLGEM91uWaxq8e63JN41ePddW0JvdRmJlZRW5RmJlZRQ4KMzOryEGRknSxpLWS1km6tob7PUHSHZIelPSApN9L58+V9B+SHk2/zknnS9Lfp3XeJ+n8KtZWlPTfkr6ZTp8s6a5031+S1JjOb0qn16XLl1SxptmSvirpYUkPSbow72Ml6Q/Sn90aSSslNedxrCTdJKlL0prMvAkfG0lvTdd/VNJbq1DTx9Kf332Svi5pdmbZ+9Oa1kp6TWb+lH0+y9WUWfZHkkJSWzpdk+NUqS5J702P1wOSPpqZX/VjNSR5BOOx/QKKwGPAKUAjcC9wVo32vRA4P33fCjwCnAV8FLg2nX8tcEP6/rXAt0ke63sBcFcVa/tD4F+Bb6bTXwauTN/fCLw7ff/bwI3p+yuBL1WxppuBd6bvG4HZeR4rYDHwBDAtc4yuzuNYAS8DzgfWZOZN6NgAc4HH069z0vdzprimVwOl9P0NmZrOSj97TcDJ6WeyONWfz3I1pfNPAL5DcsNuWy2PU4Vj9XLge0BTOj2vlsdqqI6p/uAciS/gQuA7men3A+/PqZbbgF8B1gIL03kLgbXp+38ErsqsP7TeFNdxPPB94BXAN9MPyubMB3zomKUfrgvT96V0PVWhplkkv5Q1Yn5ux4okKJ5Jf2GU0mP1mryOFbBkxC+aCR0b4CrgHzPzh603FTWNWHYF8IX0/bDP3eCxqsbns1xNwFeBc4AnORgUNTtOY/z8vgy8qsx6NTtWEeFTT6nBD/ug9em8mkpPQ5wH3AXMj4iN6aJNwPz0fa1q/STwp8BAOn0csD0i+srsd6imdPmOdP2pdjLQDXwuPSX2WUnTyfFYRcSzwMeBp4GNJP/2e8j/WA2a6LGp9Wfh7SR/sedak6TLgGcj4t4Ri/I+TqcDv5SepvyRpBflUZeDok5ImgF8Dfj9iOjJLovkT4OaXccs6fVAV0TcU6t9jlOJpGn+DxFxHrCb5HTKkByO1RzgMpIQWwRMBy6u1f4notbH5lAkXQf0AV/IuY4W4APAB/OsYwwlktbqBcCfAF+WpFoX4aBIPEtyfnLQ8em8mpDUQBISX4iIW9LZz0lamC5fCHTVsNaLgEslPQl8keT0098BsyWVyux3qKZ0+SxgyxTXBMlfR+sj4q50+qskwZHnsXoV8EREdEdEL3ALyfHL+1gNmuixqclnQdLVwOuBN6UBlmdNzyMJ+nvT//PHAz+XtCDHmgatB26JxM9IWvhtta7LQZG4GzgtvVKlkaST8Ru12HH618E/AQ9FxN9mFn0DGLyS4q0kfReD89+SXo1xAbAjc2phSkTE+yPi+IhYQnIsfhARbwLuAN4wRk2Dtb4hXX/K/3KNiE3AM5KWprNeCTxIjseK5JTTBZJa0p/lYE25HquMiR6b7wCvljQnbS29Op03ZSRdTHJa89KI2DOi1iuVXBl2MnAa8DOq/PmMiPsjYl5ELEn/z68nucBkEzkep9StJB3aSDqdpIN6M7U+VofbyXG0vEiubniE5IqB62q435eSnA64D1idvl5Lct76+8CjJFc9zE3XF/DptM77gY4q17eMg1c9nZL+Z1wHfIWDV2I0p9Pr0uWnVLGec4HO9HjdSnLFSa7HCvgL4GFgDfB5kitRan6sgJUk/SS9JL/s3jGZY0PSb7Aufb2tCjWtIzmPPvj//cbM+telNa0FLsnMn7LPZ7maRix/koOd2TU5ThWOVSPwL+n/rZ8Dr6jlsRp8eQgPMzOryKeezMysIgeFmZlV5KAwM7OKHBRmZlaRg8LMzCpyUJjVKUnL0pFMr867Fju2OSjsqJX5RfvH6fRsSR+StCzfyg6SdG5a05K8azEbS+nQq5gdNWYD16fvf5hfGcOcS1LTD0lu9MpaBUwjuQHLLDduUZhNEUmtU7m9iBiIiH0R0T+V2zWbKAeFHRPS001PpJPXp6ekIh0ELrveGyX9p6Sdkvakwzu/YcTmSL93haRXpuvvAm5Ply2S9DeSVkvaJmmfkicYvk9SMbONDwGfSyfvyNS0YrDmcn0UkqZL+mtJj0naL2mTpH+WdNLIf/Pg90t6m5InpO2X9JSkP530wbRjjk892bHiIeAPgE8AXycZ5RVg1+AKkv6SZPycfwf+nGSkziuAr0j6nYj49IhtdgC/Dvw/kifvDXoh8Gvpfh4DGkiGHv8/JGNA/Va63i0kD8G5BvhIWiPp95SVjjT8HZIRar8K/A3JgHDvJhmkriMi1o/4tneRPIfin4DtwJuBGyStj4h/HWtfZkOqMUiaX37Vw4tkQMMA/jidXpJOf6jMuuenyz5SZtmtQA/Qmpk3+GyHck8fm0aZp9aRDBjYT+YpeySPTQ1gWYX6r87M+1/pvI+OWPd16fzPl/n+DcCszPwWkgdA/STvn5FfR8bLp57MEm8i+aV6s6S27ItkmOZWksdMZt0bEd8buaGI2BsRydCjUqOkuel2vkNyurfjMOq8gqSl89cj9vlvJCOxXiZp5Of6cxGxI7PuHuCnJC0Rs0PyqSezxJkkQ0o/XGGd+SOmHym3UvpAomuBtwCnptvNmjPJGiF5wM6GiNhWZtkDJFdRtXHwAUUAj5dZdwvVfQSrHUUcFGYJkbQoLiE5PVTOAyOm95RdC/4WeC/wJeCvSH5p95Kc3rqB2l9E4qum7LA4KOxYUunhK4+SdDg/HREPVVhvPH4TWBURV2ZnSjp1gjWV8zhwsaTZEbF9xLKzSPpSNk9wm2YVuY/CjiWDVzjNLbPs8+nXj2QvYR0kaeRpp0r6GXG6SdJ0kquuJlJTObeSfG6vHbH9S4DzgG9ExMAEajU7JLco7JgREVskrSN51vBjwHPA7oi4PSLuTu9r+BCwWtJXSK4WWgj8AsnjJRvHuauvAr8l6Uskjx+dT/LYzC1l1r2bpHP6uvTZy7uBJyLirjG2vYLk2dfvS4f9WEXSD/Lb6b/nA+Os0WzcHBR2rHkTyb0UHyG5TPQp0hvlIuIvJHUCvwv8PjCdpH9hTTpvvP4Q2An8T+AykudDLycJhWFXSUXE05LeDrwP+AeSey5uBsoGRUT0SnoN8GfAG0nu19hO8hzuP4uIZyZQp9m4+JnZZmZWkfsozMysIgeFmZlV5KAwM7OKHBRmZlaRg8LMzCpyUJiZWUUOCjMzq8hBYWZmFTkozMysov8Pfcrj06+7jrUAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -768,19 +673,33 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 1)\n",
+    "ax.plot(range(len(optimizer.loss_history)), optimizer.loss_history)\n",
+    "ax.set_ylabel(\"Loss\", fontsize=FS)\n",
+    "ax.set_xlabel(\"Iteration\", fontsize=FS)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "delta_psi shift by min: -0.5827018296264791\n"
+      "delta_psi shift by mean values: -0.04470580282007689 0.3094870486449607\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 1080x1008 with 18 Axes>"
+       "<Figure size 1080x1440 with 24 Axes>"
       ]
      },
      "metadata": {
@@ -790,8 +709,13 @@
     }
    ],
    "source": [
-    "kwargs_final = deepcopy(parameters.ML_values(as_kwargs=True))\n",
-    "plot_pixelated_potential_result(optimizer, kwargs_final, with_mask=True)"
+    "plotter.set_true_potential_perturbations(psi_grid_true_lowres)\n",
+    "plotter.set_data(data)\n",
+    "\n",
+    "kwargs_final = deepcopy(parameters.best_fit_values(as_kwargs=True))\n",
+    "plotter.model_summary(hybrid_lens_image, kwargs_final,\n",
+    "                      show_lens_mass=True, potential_mask=mask_lowres,\n",
+    "                      shift_potential_model='mean')"
    ]
   },
   {
@@ -803,7 +727,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
@@ -815,7 +739,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x576 with 2 Axes>"
       ]
@@ -833,7 +757,7 @@
     "    print(\"Using approximated inverse Hessian\")\n",
     "    fisher_matrix = extra_fields['hess_inv']\n",
     "    \n",
-    "    imin, imax = 95, 105\n",
+    "    imin, imax = 120, 140\n",
     "    \n",
     "    best_fit_red = best_fit[imin:imax]\n",
     "    fisher_matrix_red = fisher_matrix[imin:imax, imin:imax]\n",
@@ -856,14 +780,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 1080x1080 with 100 Axes>"
+       "<Figure size 1080x1080 with 400 Axes>"
       ]
      },
      "metadata": {
@@ -879,7 +803,7 @@
     "    return r\n",
     "\n",
     "if fisher_matrix is not None:\n",
-    "    samples_fisher = draw_from_gaussian(best_fit_red, fisher_matrix_red, ndraws=10000)\n",
+    "    samples_fisher = draw_from_gaussian(best_fit_red, fisher_matrix_red, ndraws=5000)\n",
     "\n",
     "    fig = plt.figure(figsize=(15, 15))\n",
     "    fig = corner.corner(samples_fisher, truths=p_true_red, show_titles=True, labels=symbols_red,\n",
@@ -889,12 +813,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
diff --git a/notebooks/fit_pixelated_compact_potential_and_pixelated_source.ipynb b/notebooks/fit_pixelated_compact_potential_and_pixelated_source.ipynb
index 2899221..358d2ea 100644
--- a/notebooks/fit_pixelated_compact_potential_and_pixelated_source.ipynb
+++ b/notebooks/fit_pixelated_compact_potential_and_pixelated_source.ipynb
@@ -7,7 +7,7 @@
     "# Find a localised dark matter halo along with the source\n",
     "### Fit pixelated lens potential perturbations and a pixelated source, assuming a known SIE model\n",
     "\n",
-    "__last update__: 28/07/21"
+    "__last update__: 28/07/21 (not compatible with latest updates!)"
    ]
   },
   {