notebooks/050_Models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img alt='UCL' src=\"images/ucl_logo.png\" align='center'>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "[<img src=\"images/noun_post_2109127.svg\" width=\"50\" align='right'>](051_Phenology_model.ipynb)\n",
    "[<img src=\"images/noun_pre_2109128.svg\" width=\"50\" align='right'>](043_Weighted_interpolation.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 050 Models\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "In this session, we will consider the idea of a model in (Environmental) Science and discuss some examples. The material in this section brings together a lot of the techniques we have dealt with in previous sessions, so you should make sure you are up to speed with concepts like array processing, graph plotting and writing Python functions and scripts before attempting this.\n",
    "\n",
    "You will need to understand the material in this section to be able to complete the second half of the submitted coursework.\n",
    "\n",
    "## Prerequisites\n",
    "\n",
    "You will need a good understanding of previous topics involving [`np.mgrid`](031_Numpy.ipynb#np.linspace,-np.arange,-np.mgrid) and [`np.newaxis`](032_More_numpy.ipynb#Reconciling-arrays:-np.newaxis). You should by now be familiar with other more basic material. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Models \n",
    "\n",
    "We can think of a model as a 'process' box encapsulating our understanding, or a proposal for our understanding, of some process. Two examples we will cover later are:\n",
    "\n",
    "* a descriptive model of vegetation phenology\n",
    "* a model of snow-melt\n",
    "\n",
    "Such models make an *output prediction* will be some variable, or set of variables. For our two example models, these will be:\n",
    "\n",
    "* LAI as a function of time\n",
    "* river flow resulting from snow-melt\n",
    "\n",
    "The **outputs** depend on the mechanics of our model and:\n",
    "\n",
    "* some set of **driving data** (in our two models this will be simply time, and time and temperature, respectively) \n",
    "* some model parameters\n",
    "\n",
    "The model parameters control the operation of the model. These could be related to the type of vegetation for a phenology model, or terms such as the thickness of snowpack in the case of a snow-melt model. Most often, the parameters will describe *states* and *rates*, for example, the current amount of water in a snowpack (state) or the rate at which water is released from the snowpack into runoff (rate)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![model](images/parameters1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will generally have access to the driving data for our model, and we will have some set of measurements that correspond to the output, but we may not know the values of the parameters to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![model](images/parameters2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How can we use this to provide an estimate of the model parameters? We could make some educated guesses, based on previous experience with the model in different situations ('expert opinion'), and we might also be able to provide reasonable bounds for the parameters, again either based on previous experience with the model or sometimes simply from physical limits (e.g. some parameters cannot be negative). \n",
    "\n",
    "What we really want is a more objective way of estimating the parameters. This involves parameter optimisation, which is a whole field of science. We cannot cover that in this course, but we can introduce some of the main ideas to use in our codes.\n",
    "\n",
    "Before moving on to more 'realistic' models, let's build a simple example model `model` we can learn from. \n",
    "\n",
    "This has two parameters `p[0]` and `p[1]` and a driver that represents time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple model \n",
    "def model(driver,param):\n",
    "    '''2-parameter quadratic model with noise'''\n",
    "    return param[0] + param[1] * driver * driver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will generate a dataset `measure` at time samples `tmdriver` to represent our measurements, We generate them with the model with a set of parameters and some additive noise. We will also generate a set of weights for the observations, which we will use to indicate their reliability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# time driver every 4 days for measurement\n",
    "tmdriver = np.arange(0,365,4,dtype=np.int)\n",
    "# generate a pseudo-measurement\n",
    "p0 = np.array([0.4,0.0002])\n",
    "measure = model(tmdriver,p0) + 5*(np.random.random(tmdriver.shape)-0.5)\n",
    "# just make up some weights for this exercise\n",
    "measure_weight = (2 + np.random.random(tmdriver.shape))/4\n",
    "# convert to std for plotting as previously\n",
    "std = 1./np.sqrt(measure_weight) * 1.96"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we forget that we know the parameters, make a guess that they are `[0.3,0.0001]`, and use the model to make a prediction `output`. Note that `output` exists every day, whereas the measurements are only every 4 days."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Unable to revert mtime: /Library/Fonts\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "measurements: tmdriver shape (92,)\n",
      "model output: tdriver shape  (365,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# time driver every day\n",
    "tdriver = np.arange(0,365,1,dtype=np.int)\n",
    "# guess parameters\n",
    "p = np.array([0.3,0.0001])\n",
    "toutput  = model(tdriver,p)\n",
    "\n",
    "\n",
    "# plot\n",
    "fig, axs = plt.subplots(1,1,figsize=(10,3))\n",
    "axs.set_xlim(0,365)\n",
    "axs.plot(tdriver,toutput,'k',label='modelled values')\n",
    "axs.errorbar(tmdriver,measure,yerr=std,ls='none')\n",
    "axs.plot(tmdriver,measure,'r+',label='measured values')\n",
    "# set legend now\n",
    "axs.legend(loc='best')\n",
    "axs.set_xlabel(f'time / days')\n",
    "\n",
    "print(f'measurements: tmdriver shape {tmdriver.shape}')\n",
    "print(f'model output: tdriver shape  {tdriver.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see right away that there is a mis-match between the model outputs and the measurements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### discrepancy and optimisation\n",
    "\n",
    "We have a set of *observations* that correspond to the model outputs at some time samples. \n",
    "\n",
    "A simple operation we can do is to compare these then. We might suppose that a set of parameters that provides a lower discrepancy between observations and modelled values (we will often call this error) is *objectively better* than one with a poorer match. In that sense, what we would need to do would be to search for a set of parameters that which has the minimum error. Our search for parameters will be guided by any bounds we set. Then all we need to do is write some computer code that considers different values of the parameters and reports on the best (the optimal) match.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![model](images/parameters3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is a reasonable approach, and one we will take in these notes. We should be aware that when we do Science however, we need to take into account uncertainty, and also that there might be other constraints we want to put on the problem.\n",
    "\n",
    "Uncertainty manifests itself at all stages of modelling and optimisation: the model itself will be uncertain, because of its nature as an abstraction of some process; the drivers will often be uncertain in their ability to the conditions at the actual place and time we are doing the modelling; and the measurements will be uncertain. We have treated uncertainty in other sections of these notes by applying a weight to observations, and we can take the same approach here. When we calculate error, for instance as the root mean square error between model predictions (output) and measurement, we can weight this to give a weighted error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we can calculate the (weighted) error, we need to treat the outputs so that they match the time samples of the measurements. We can either match the observations to the measurements, or the measurements to the observations. The best approach will depend on circumstances but generally it is simplest to run the model for each observation driver. If your model involves some summation (integral) over time, then you need to think carefully about how to do this.\n",
    "\n",
    "In this example though it is straightforward: we just run the model for the time locations that we have observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tmoutput shape: (92,)\n",
      "tmdriver shape: (92,)\n",
      "tdriver shape: (365,)\n"
     ]
    }
   ],
   "source": [
    "# run the model for measurement times only\n",
    "tmoutput = model(tmdriver,p)\n",
    "# check the shape\n",
    "print(f'tmoutput shape: {tmoutput.shape}')\n",
    "print(f'tmdriver shape: {tmdriver.shape}')\n",
    "print(f'tdriver shape: {tdriver.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE: 3.9623187745427155 for parameters [3.e-01 1.e-04]\n"
     ]
    }
   ],
   "source": [
    "# now we can calculate the weighted discrepency \n",
    "error = (tmoutput - measure)*measure_weight\n",
    "error2 = error**2\n",
    "rmse = np.sqrt(np.mean(error2))\n",
    "print(f'RMSE: {rmse} for parameters {p}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "measurements: measure shape  (92,)\n",
      "model output: tmoutput shape (92,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot\n",
    "fig, axs = plt.subplots(1,1,figsize=(10,3))\n",
    "axs.set_xlim(0,365)\n",
    "axs.plot(tmdriver,tmoutput,'r+',label='modelled values')\n",
    "axs.plot(tmdriver,measure,'g+',label='measured values')\n",
    "# plot the discrepencies as error bars using errorbar\n",
    "axs.errorbar(tmdriver,measure,\\\n",
    "             yerr=[measure-measure,tmoutput-measure],ls='none',\\\n",
    "             label='error')\n",
    "\n",
    "# set legend now\n",
    "axs.legend(loc='best')\n",
    "axs.set_xlabel(f'time / days')\n",
    "\n",
    "print(f'measurements: measure shape  {measure.shape}')\n",
    "print(f'model output: tmoutput shape {tmoutput.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fba984437d0>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# scatter plot\n",
    "fig, axs = plt.subplots(1,1,figsize=(5,5))\n",
    "# max value over all\n",
    "maxvalue = np.array([measure,tmoutput]).max()\n",
    "axs.set_xlim(0,maxvalue)\n",
    "axs.set_ylim(0,maxvalue)\n",
    "\n",
    "axs.plot(measure,tmoutput,'r+')\n",
    "axs.errorbar(measure,tmoutput,yerr=std,ls='none')\n",
    "\n",
    "axs.set_ylabel(f'model output')\n",
    "axs.set_xlabel(f'measurement')\n",
    "# 1:1 line\n",
    "axs.plot([0,maxvalue],[0,maxvalue],'k')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Varying the parameters\n",
    "\n",
    "We have seen how, once we have aligned the model outputs and observations, we can calculate a weighted measure if error, RMSE here. So, so some given set of measurements, a model, and a set of model parameters, we can calculate the error:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![model](images/parameters4.png)\n",
    "\n",
    "Re-generate the set of measurements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# simple model \n",
    "def model(driver,param):\n",
    "    '''2-parameter quadratic model with noise'''\n",
    "    return param[0] + param[1] * driver * driver\n",
    "\n",
    "# time driver every 4 days for measurement\n",
    "tmdriver = np.arange(0,365,4,dtype=np.int)\n",
    "\n",
    "# generate a pseudo-measurement\n",
    "# NB different to above\n",
    "p0 = np.array([0.6,0.0005])\n",
    "\n",
    "# np.random.random(tmdriver.shape)-0.5 -> zero mean noise\n",
    "measure = model(tmdriver,p0) + 5*(np.random.random(tmdriver.shape)-0.5)\n",
    "# just make up some weights for this exercise\n",
    "measure_weight = (2 + np.random.random(tmdriver.shape))/4\n",
    "# convert to std for plotting as previously\n",
    "std = 1./np.sqrt(measure_weight) * 1.96"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recap on the core components so far, but setting the parameters to `numpy` arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p0 shape:    (1,)\n",
      "p1 shape:    (1,)\n",
      "tmdriver shape: (92,)\n",
      "tmoutput shape: (92,)\n"
     ]
    }
   ],
   "source": [
    "# some test parameters\n",
    "p0,p1 = np.array([0.1]),np.array([0.2])\n",
    "\n",
    "tmoutput  = model(tmdriver,[p0,p1])\n",
    "\n",
    "print(f'p0 shape:    {p0.shape}')\n",
    "print(f'p1 shape:    {p1.shape}')\n",
    "print(f'tmdriver shape: {tmdriver.shape}')\n",
    "print(f'tmoutput shape: {tmoutput.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now build a Look-up table (LUT) in parameter space to examine how the RMSE varies as we vary the model parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Use mgrid as previously to define a 2D grid of parameters\n",
    "p0min,p0max,p0step = 0.0,10.0,1\n",
    "p1min,p1max,p1step = 0.0,0.0011,0.0001\n",
    "p0,p1 = np.mgrid[p0min:p0max+p0step:p0step,\\\n",
    "                 p1min:p1max+p1step:p1step]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2d parameter grid\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, axs = plt.subplots(1,1,figsize=(5,5))\n",
    "axs.plot(p0,p1,'+')\n",
    "axs.set_xlabel('p0')\n",
    "axs.set_ylabel('p1')\n",
    "\n",
    "print('2d parameter grid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall from [032 `reshape`](032_More_numpy.ipynb#Changing-shape:-flatten,-ravel-and-reshape) that although the LUT is 2-D, we will mostly want to operate on a 1D ravelled version. So let's generate that from the outset:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of p0 : (11, 12)\n",
      "shape of p0_ : (132,)\n"
     ]
    }
   ],
   "source": [
    "p0_ = np.ravel(p0)\n",
    "p1_ = np.ravel(p1)\n",
    "print(f'shape of p0 : {p0.shape}')\n",
    "print(f'shape of p0_ : {p0_.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "In [032 `np.newaxis`](032_More_numpy.ipynb#Reconciling-arrays:-np.newaxis) we saw how to use `np.newaxis` to reconcile two arrays for element-wise processing. Here, have the 1D arrays `tdriver` and the `p0_` and `p1_` and we want to be able to describe all parameters for all time locations;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p0_ext shape:       (1, 132)\n",
      "p1_ext shape:       (1, 132)\n",
      "tmdriver_ext shape: (92, 1)\n",
      "tmoutput shape:     (92, 132)\n"
     ]
    }
   ],
   "source": [
    "p0_ext       = p0_[np.newaxis,:]\n",
    "p1_ext       = p1_[np.newaxis,:]\n",
    "tmdriver_ext = tmdriver[:,np.newaxis]\n",
    "\n",
    "print(f'p0_ext shape:       {p0_ext.shape}')\n",
    "print(f'p1_ext shape:       {p1_ext.shape}')\n",
    "print(f'tmdriver_ext shape: {tmdriver_ext.shape}')\n",
    "\n",
    "# we can now call the model with extended arrays\n",
    "# to produce model output for all parameters and \n",
    "# time samples\n",
    "tmoutput  = model(tmdriver_ext,[p0_ext,p1_ext])\n",
    "print(f'tmoutput shape:     {tmoutput.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to be able to compare `tmoutput` with `measure` and `measure_weight`, so lets do that to align with the parameter grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "measure_ext shape:        (92, 1)\n",
      "measure_weight_ext shape: (92, 1)\n"
     ]
    }
   ],
   "source": [
    "measure_ext        = measure[:,np.newaxis]\n",
    "measure_weight_ext = measure_weight[:,np.newaxis]\n",
    "print(f'measure_ext shape:        {measure_ext.shape}')\n",
    "print(f'measure_weight_ext shape: {measure_weight_ext.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now perform element-wise operations involving `measure_ext`, `measure_weight_ext` and `tmoutput`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error_ext shape: (92, 132)\n"
     ]
    }
   ],
   "source": [
    "error_ext = (tmoutput - measure_ext)*measure_weight_ext\n",
    "error_ext = error_ext*error_ext\n",
    "print(f'error_ext shape: {error_ext.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now calculate the square root of the mean of this squared error term `error_ext` over time samples (axis 0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rmse shape (132,)\n",
      "min rmse\n",
      "0.931498404380905\n"
     ]
    }
   ],
   "source": [
    "rmse = np.sqrt(np.mean(error_ext,axis=0))\n",
    "\n",
    "print(f'rmse shape {rmse.shape}')\n",
    "min_rmse = rmse.min()\n",
    "print(f'min rmse\\n{min_rmse}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following the material in [032](032_More_numpy.ipynb#Simplifying-shape:-flatten,-ravel,-reshape-and-unravel_index) we use `argmin` to find the parameter index of minimum RMSE:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D index of minimum  : 5\n",
      "parameter at minimum : 0.0,0.0005\n"
     ]
    }
   ],
   "source": [
    "# use np.argmin to find the minimum\n",
    "imin = np.argmin(rmse)\n",
    "p0min,p1min = p0_[imin],p1_[imin]\n",
    "print(f'1D index of minimum  : {imin}')\n",
    "print(f'parameter at minimum : {p0min},{p1min}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "To convert the index back to the unflattened array, we can use [`np.unravel_index`](032_More_numpy.ipynb#Simplifying-shape:-flatten,-ravel,-reshape-and-unravel_index) as before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2D index of minimum point: 0, 5\n",
      "parameter at minimum : 0.0,0.0005\n"
     ]
    }
   ],
   "source": [
    "ip0min,ip1min = np.unravel_index(imin,p0.shape)\n",
    "\n",
    "print(f'2D index of minimum point: {ip0min}, {ip1min}')\n",
    "p0min = p0[ip0min,ip1min]\n",
    "p1min = p1[ip0min,ip1min]\n",
    "print(f'parameter at minimum : {p0min},{p1min}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of the 11 x 12  combinations of parameters we examined, the parameters `[1.0,0.0005]` provide the best fit to the data. We had generated the 'measurements' with:\n",
    "\n",
    "    p0 = np.array([0.6,0.0005])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualisation of RMSE\n",
    "\n",
    "We can find it useful to visualise the RMSE 'error surface' and then plot the measurements and forward model. Since we have a flattened version, we will need to apply `reshape` before loading it. We reshape it to the same shape as `p0`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reshape to plot\n",
    "_rmse = rmse.reshape(p0.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, a graph of the RMSE values as a function of parameter 0 index. We set the maximum value in the plots below to 10 times the minimum RMSE value, as this should let us see some detail in the error function, without swamping the plot with error values that are not at all feasible. This factor of 5 is a little arbitrary, and you might need to experiment with it, but it is not a bad rule of thumb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'parameter index')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# plot rmse as function of parameter index\n",
    "pindex = np.arange(_rmse.shape[0])\n",
    "fig, axs = plt.subplots(1,1,figsize=(10,3))\n",
    "axs.plot(pindex,_rmse,'r+')\n",
    "axs.plot([p0min],[min_rmse],'ko',label='minimum RMSE')\n",
    "# set upper bound so we can see the detail\n",
    "axs.set_ylim(0,min_rmse*5)\n",
    "axs.set_xlabel(f'parameter index')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fba985c5e10>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Plot the RMSE values returned from this as an image\n",
    "\n",
    "# plot it\n",
    "fig, axs = plt.subplots(1,1,figsize=(5,4))\n",
    "# plot reshaped rmse\n",
    "im = axs.imshow(rmse.reshape(p0.shape),\\\n",
    "                interpolation=\"nearest\",\\\n",
    "                vmax=min_rmse*5,cmap=plt.cm.inferno_r)\n",
    "fig.colorbar(im, ax=axs)\n",
    "axs.set_xlabel('p0')\n",
    "axs.set_ylabel('p1')\n",
    "# notice we plot ip1min,ip0min to overlay the image\n",
    "plt.plot([ip1min],[ip0min],'r+',label=\"minimum RMSE\")\n",
    "axs.legend(loc='lower right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is useful to look at such plots because we can use them to gauge  the uncertainty in the parameter solution. In this case, we see that the error surface is long and narrow in parameter 1. So even though we have reported the optimal value as 1.0, it could vary considerably and not change the RMSE value considerably. This is an important part of the interpretation of our results, and helps explain why we solved for a parameter value of 1.0 even though we fed the measurements with a value of 0.6.\n",
    "\n",
    "One other thing these plots are useful for is to check that our solution does not lie on the boundary of the parameter space. Unless there is a good physical reason for the bounds we have imposed on the parameters in generating the LUT grid, if we find our solution is on a parameter boundary we might just be not sampling the parameter space well enough. Related to this, we also would like to see some spread of the RMSE values, rather than just a single low point, as this might otherwise indicate that our sampling grid is too coarse. The example above is good model for what you should be looking for the the RMSE plots, although the grid is a little coarse. Remember from above that we have thresholded the plot at 10 times the minimum RMSE so we can see the detail of the plot around the minimum point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now visualise the model and measurents for the 'optimum' parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.     0.0005]\n",
      "measurements: tmdriver shape (92,)\n",
      "model output: tdriver shape  (365,)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAADRCAYAAAADkYwRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAA+SklEQVR4nO3dd3zURf7H8dckhN5DCJ0ERUooIQQEUYoo6CHInRQ5BBRBVFAsFDnUhNM7sR4KWBBQRAQEzoryEzkRkSgQegelBULAAIFQQiDz+2M3MSG7yW5Ihffz8djH7s5+d76zw1f4ODPfzxhrLSIiIiLiOZ+CboCIiIhIUaMASkRERMRLCqBEREREvKQASkRERMRLCqBEREREvKQASkRERMRL2QZQxpgGxpgN6R6njDFPGGMqG2OWGmN2O58r5UeDRURERAqa8SYPlDHGFzgE3AgMB45baycaY54BKllrx2b1/SpVqtigoKAraK6IiIhI/oiOjv7DWhvg6rNiXtbVGfjNWrvfGHM30NFZPgtYDmQZQAUFBbF27VovTykiIiKS/4wx+9195u0aqHuBuc7XgdbaWADnc9WcNU9ERESkaPE4gDLGFAd6AAu8OYEx5iFjzFpjzNpjx4552z4RERGRQsebEag7gXXW2jjn+zhjTHUA5/NRV1+y1k6z1oZba8MDAlxOI4qIiIgUKd6sgerHn9N3AF8Cg4CJzucvctKA5ORkYmJiOH/+fE6+LkVAyZIlqVWrFn5+fgXdFBERkVzhUQBljCkN3A4MS1c8EfjUGPMgcADonZMGxMTEUK5cOYKCgjDG5KQKKcSstcTHxxMTE0NwcHBBN0dERCRXeBRAWWvPAv6XlcXjuCvvipw/f17B01XMGIO/vz9a/yYiIgWh73tRAMwf1jZX6y0UmcgVPF3d9OcrIiJXm0IRQF1NgoKC+OOPPzw+pmzZsl7VHxkZyWuvvZbj9uV2PSIiIoVB3/ei0kabLtfrq+keH9/n3VXc9u+vyS7RuLeJNEVERESKlN6LZwIzsjzmwoULfPTRR6xencj58+eJiqqc5fHX/AjUvn37aNiwIUOGDKFJkyb079+f77//nnbt2lG/fn1Wr14NwPHjx+nZsyfNmjWjTZs2bNq0CYD4+Hi6dOlCixYtGDZsWIaI9eOPP6Z169aEhoYybNgwLl26lGVbXn31VVq1akWzZs2IiIhIK//Xv/5FgwYNuO2229i5c2em7yUkJBAUFERKSgoAZ8+epXbt2iQnJ/P+++/TqlUrmjdvzj333MPZs2czfb9jx45pGeL/+OMPUrfbuXTpEqNHj05r03vvvQdAbGws7du3JzQ0lCZNmvDTTz952t0iIiJ5xtVIU3bOnz/P1KlTuf766xk6dCh+fn68EreJNm3aZPm9QjUC9cQTT7Bhw4ZcrTM0NJRJkyZlecyePXtYsGAB06ZNo1WrVnzyySesXLmSL7/8kn//+998/vnnRERE0KJFCz7//HP+97//MXDgQDZs2MCECRO4+eabef7551m8eDHTpk0DYPv27cyfP5+ff/4ZPz8/Hn30UebMmcPAgQNdtuG7775j9+7drF69GmstPXr0YMWKFZQpU4Z58+axfv16Ll68SFhYGC1btszw3QoVKtC8eXN+/PFHOnXqxFdffUXXrl3x8/Pjb3/7G0OHDgXg2WefZcaMGTz22GMe9d2MGTOoUKECa9asISkpiXbt2tGlSxf++9//0rVrV8aPH8+lS5dcBmUiIiL5LcNIU2QkTJjA/NQPU9fjRkRAZCQpKSncMXcS9Sb8TGxsLDfddBPTpk3jg/0VGDhtBPh8kuW5ClUAVVCCg4Np2rQpACEhIXTu3BljDE2bNmXfvn0ArFy5kkWLFgFw6623Eh8fT0JCAitWrOC///0vAN26daNSpUoALFu2jOjoaFq1agXAuXPnqFrV/W433333Hd999x0tWrQAIDExkd27d3P69Gn++te/Urp0aQB69Ojh8vt9+/Zl/vz5dOrUiXnz5vHoo48CsGXLFp599llOnjxJYmIiXbt29bhfvvvuOzZt2sTChQsBx0jX7t27adWqFYMHDyY5OZmePXsSGhrqcZ0iIiL5IjISIiPp+14U8x++CZwzRKdPn2bqxIn8st2PBT8tZE6nTsyZM4eOHTtijOEDN+uoLleoAqjsRorySokSJdJe+/j4pL338fHh4sWLAC4Xk6XeXebqLjNrLYMGDeKll17yqA3WWsaNG8ewYcMylE+aNMmju9h69OjBuHHjOH78ONHR0dx6660A3H///Xz++ec0b96cDz/8kOXLl2f6brFixdKm/9InNLXWMnnyZJdB14oVK1i8eDEDBgxg9OjRbkfWRERE8lQ2I02pTp48yVtvvcWkSZM4ceIEDYe/C8D//vc/t/W0hIxTPulc82ugPNW+fXvmzJkDwPLly6lSpQrly5fPUP7tt99y4sQJADp37szChQs5etSxw83x48fZv9/tps507dqVmTNnkpiYCMChQ4c4evQo7du357PPPuPcuXOcPn2ar776yuX3y5YtS+vWrRk5ciR33XUXvr6+gCPSrl69OsnJyWntvFxQUBDR0dEAaaNNqW165513SE5OBmDXrl2cOXOG/fv3U7VqVYYOHcqDDz7IunXrPOtEERGR3BYZCdbS991VjvfWOh7O4Ck5+QLvt/sbdevWJSIigqkBAVhg+9SHHccb82fQdVk90RDt7rSFagSqMIuMjOSBBx6gWbNmlC5dmlmzZgEQERFBv379CAsLo0OHDtSpUweAxo0b8+KLL9KlSxdSUlLw8/Nj6tSp1K1b12X9Xbp0Yfv27bRt60j0VbZsWT7++GPCwsLo27cvoaGh1K1bl1tuucVtG/v27Uvv3r0zjDK98MIL3HjjjdStW5emTZty+vTpTN8bNWoUffr0Yfbs2WkjVwBDhgxh3759hIWFYa0lICCAzz//nOXLl/Pqq6/i5+dH2bJl+eijj7zuTxERkby0f/9+Xn31VX45WYdVdVpxR81ijBs3Lm3ZyeVTe94y2eU5yE3h4eE29W6vVNu3b6dRo0b51gYpGPpzFhGRvNT3vSh6fTWdJq+O4uWXX2bOnDkYYxg4cCBjxozhhhtuyHS8qwAqtZ7eX8/AGBNtrQ13dT6NQImIiEiRd/r0aSbUa8u2kBBKlizJ8OHDefrpp6ldu7bb7yzoNtjlRr4Luw/JdoNfBVAiIiJS6Hiyh521lh9//JF///vfbKpyK8WK+TJ+/Hgef/xxAgICsj2Hq0DJ0z3zPAqgjDEVgelAE8ACg4GdwHwgCNgH9LHWnvDorCIiIiLZ6PXVdHAR0Fhr+frrr3nppZeIiooiMDCQp566jYcfHkb58uU9qvtKNxf29C68N4El1tqGQHNgO/AMsMxaWx9Y5nwvIiIikisciTH/dPHiRTq98AXXPzSFHj16EBsby9SpU9m7dy9jxozxOHjKDdkGUMaY8kB7nKk9rbUXrLUngbuBWc7DZgE986aJIiIicrXKahPgVElJSUybNo0GDRqwfft2rLV89NFH7Nq1i0cffZRSpUrlU2v/5MkIVD3gGPCBMWa9MWa6MaYMEGitjQVwPrtMs22MecgYs9YYs/bYsWO51nARERG5CkVGgjGOO+QAjKFEyZIcHjYMf39/QkJCePnIRgYMGICfn1+BNdOTAKoYEAa8Y61tAZzBi+k6a+00a224tTbckwVd4p2yZcsWqnpERES8lWET4MhIDsXE0GrMxwAY4PbbbuPmpUv59ddfqVKlSqapvYLgSQAVA8RYa391vl+II6CKM8ZUB3A+H82bJrqRLj371SZ1+xgREZHCKKtpN0+m5C6XGhBt3bqVBx54gODgYA4ePAjAunXrWLp0KbfddptHW5vll2wDKGvtEeCgMaaBs6gzsA34EhjkLBsEfJEnLXRnwoRcqWbfvn00bNiQIUOG0KRJE/r378/3339Pu3btqF+/PqtXrwbgzJkzDB48mFatWtGiRQu++OKLtO/fcssthIWFERYWxqpVjhTwsbGxtG/fntDQUJo0acJPP/0EZBzpWbhwIffffz/g2LPuqaeeolOnTowdO5bffvuNO+64g5YtW3LLLbewY8cOAPbu3Uvbtm1p1aoVzz33nMvfNHbsWN5+++2095GRkbz++uskJibSuXNnwsLCaNq0adpvSG/58uXcddddae9HjBjBhx9+CEB0dDQdOnSgZcuWdO3aldjYWADeeustGjduTLNmzbj33nu9/jMQERHp3r07TZo0Yf78+Tz88MPceOONLOg2mBYtWjgOcDG1hzEFN6Birc32AYQCa4FNwOdAJcAfx913u53PlbOrp2XLlvZy27Zty1TmEcjZ9y6zd+9e6+vrazdt2mQvXbpkw8LC7AMPPGBTUlLs559/bu+++25rrbXjxo2zs2fPttZae+LECVu/fn2bmJhoz5w5Y8+dO2ettXbXrl029Te+9tpr9sUXX7TWWnvx4kV76tQpa621ZcqUSTv3ggUL7KBBg6y11g4aNMh269bNXrx40Vpr7a233mp37dplrbX2l19+sZ06dbLWWtu9e3c7a9Ysa621U6ZMyVBfqnXr1tn27dunvW/UqJHdv3+/TU5OtgkJCdZaa48dO2avu+46m5KSkqFdP/zwg+3WrVvad4cPH24/+OADe+HCBdu2bVt79OhRa6218+bNsw888IC11trq1avb8+fPp/WNKzn+cxYRkUKnz7ur7KfdBnv1WZ93V9k+765Ke3/puedSd63L8DgzerTL49PXk1sxQHaAtdZNTONRHihr7QbAVSrzzlcYv3nHuVNyGjc7LnsrODiYpk2bAhASEkLnzp0xxtC0aVP27dsHwHfffceXX37Ja6+9BsD58+c5cOAANWrUYMSIEWzYsAFfX1927doFQKtWrRg8eDDJycn07Nkzbe+drPTu3RtfX18SExNZtWoVvXv/md4rKSkJgJ9//plFixYBMGDAAMaOHZupnhYtWnD06FEOHz7MsWPHqFSpEnXq1CE5OZl//OMfrFixAh8fHw4dOkRcXBzVqlXLtm07d+5ky5Yt3H777QBcunSJ6tWrA9CsWTP69+9Pz5496dmzZ7Z1iYhI0eeYdpvh9Wfnz5/no48+4rV589gN1H3gP+z74EnOnjlD6dKlKe087krzNOW1opWJPDLyz0DJmBxvAHi5EiVKpL328fFJe+/j45O2Hslay6JFi2jQoEGG70ZGRhIYGMjGjRtJSUmhZMmSALRv354VK1awePFiBgwYwOjRoxk4cGCG+dvz589nqKtMmTIApKSkULFiRTZs2OCyvZ7MAffq1YuFCxdy5MiRtGm1OXPmcOzYMaKjo/Hz8yMoKChTG4oVK0ZKSkqmNlprCQkJISoq87z24sWLWbFiBV9++SUvvPACW7dupVixonVpiYhI3rp48SKHDx8mKOivxMXFER4ezqeffsrC4zXhAyhdunT2lTi524IlP3maSPOa17VrVyZPnpw6pcn69esBSEhIoHr16vj4+DB79mwuXboEOHaBrlq1KkOHDuXBBx9k3bp1AAQGBrJ9+3ZSUlL47LPPXJ6rfPnyBAcHs2DBAsARvGzcuBGAdu3aMW/ePMARELlz7733Mm/ePBYuXEivXr3S2lq1alX8/Pz44Ycf2L9/f6bv1a1bl23btpGUlERCQgLLli0DoEGDBhw7diwtgEpOTmbr1q2kpKRw8OBBOnXqxCuvvMLJkydJTEz0omdFRKTIyGodkpvPEp58kqeeeopffonini/fJywsjB9++IHVq1c7Z1oMC7oN9qoZC7sPycUflTNFN4CKiMjX0z333HMkJyfTrFkzmjRpkraA+9FHH2XWrFm0adOGXbt2pY0iLV++nNDQUFq0aMGiRYsYOXIkABMnTuSuu+7i1ltvTZsCc2XOnDnMmDGD5s2bExISkrbg+80332Tq1Km0atWKhIQEt98PCQnh9OnT1KxZM+08/fv3Z+3atYSHhzNnzhwaNmyY6Xu1a9emT58+adNyqYv3ihcvzsKFCxk7dizNmzcnNDSUVatWcenSJe677z6aNm1KixYtePLJJ6lYsaL3HSwiIoVfZCRYS993HTdMpa1cSg2g0n22ZvVq+t17L/6TJzN58mSqVAlg1JZlfPPNN3Ts2DHDbIo3AdH8YW0LxfSesbk0DeaJ8PBwu3bt2gxl27dvp1GjRvnWBikY+nMWESl63G3o2/e9KMdI02UxxKVLl+gy8RuWPdsDA1SoUIGHHnqIESNGMPrbQy6/48mmwQXFGBNtrXW1BrwIj0CJiIhIgUk/7ZaYmMjkyZO54YYb2Lp1K5NCuzJp0iQOHjzIK6VLU6duXbfpBwrLiJK3FECJiIiIWxmyhKezsPsQYmJiGDt2LLVr1+bxxx+nWrVqjhuOHn6ekSNHUq5cuayn/YowBVAiIiLilqttU8aEF6fYiikEBwfz2muv0aVLF6Kiovj555+pUqUKjg1Yrm6F4l5za22hSs8uuSs/19mJiIj3PFmHlJKSwtdff80bb7zBjz/+SLly5Xj88cd57LHHCAoKSjsuqzoKQ/qB3FLgAVTJkiWJj4/H399fQdRVyFpLfHx8Wn4sEREpApyJq+envjcGH2AdsLdOHV5//XUefPBBKlSo4FW1C7sPUQCVW2rVqkVMTAzHjh0r6KZIHilZsiS1atUq6GaIiEgWen01HVJHjyIjOTB4MPe8/RNrXr4PA7Ru3Zqnn36a3/72txwlSy6KC8WzUuABlJ+fH8HBwQXdDBERkWta78UzsXY6K1eu5M033+Szzz4joO+/AMc2Ym3bttVMUToFHkCJiIhI7soqf5Or8tQtvMLCwtiwYQOVKlVi1KhR7Kx5IwtODab3TTflQ6uLFo/uwjPG7DPGbDbGbDDGrHWWVTbGLDXG7HY+V8rbpoqIiEh6fd+LSguKcuLUU0+BMSx49GYA1m/YgAXiHnmEl19+mRIlShaKbVMKI2/SGHSy1oamy8j5DLDMWlsfWOZ8LyIiIvnIXZ6mrMpXrVrFvc5tVnyMIeSxaQDYlBSwFr9/OabuimqSy/xwJXmg7gZmOV/PAnpecWtERETEK67yNLkqT0pKIi4ujt6LZ9KuXTuWLFnC448/zp49e2gS0gRAa5y84GkAZYHvjDHRxpiHnGWB1tpYAOdzVVdfNMY8ZIxZa4xZqzvtRERE8ldsbCwRERHUqVOHHTt2APD2228TExPD66+/Tr169YCMW7NI9jzaTNgYU8Nae9gYUxVYCjwGfGmtrZjumBPW2izXQbnaTFhERES85MzTlEmHDvDjj5mKlwMdXdUTEVHkt1TJS1e8mbC19rDz+SjwGdAaiDPGVHeeoDpwNHeaKyIiIllys7/c2W++Yfr773P90MkAlC9XjidGjqTmrl1X5X50BSnbNAbGmDKAj7X2tPN1F+CfwJfAIGCi8/mLvGyoiIiIuLZr1y7eeecdPvzwQ06ePEm9IW8BcOjQIceGvpLrPMkDFQh85lxYVgz4xFq7xBizBvjUGPMgcACumuzsIiIihd6lS5eIj49nSng3HmvQgGLFinHPPfcwfPhwpmwrxoLYwfR2ETxdTfvRFaRsAyhr7e9Acxfl8UDnvGiUiIiIuHb06FGmT5/Oe++9R1K7R9jdpDMv3N2GIUOGUK1aNQCmbItyu+/c1bQfXUFSJnIREZE84C7rd07rOnXqFJU3fMSCBQtITk6mc+fODO/dgO7du2fam87dOZXTKfcogBIRESmkzpw5w5w5c1gbncSZxDOcW/w1jzzyCI888ggNGzYs6OZd0xRAiYiI5JFeX00HD/ejS2/btm1MmzaNDz/8kISEBOoNeYuXDq+nz+HDlClTJk/bLJ65kkzkIiIikgV3WcJdOX/+PB3/+TkNHnmHkJAQ3n77bbp168bKlSsJDw/ngR8/VfBUiCiAEhERyWfp96nbvn07Tz75JDVr1mTHjh1cuHCBV155hUOHDjFnzhzatWtXgC0VdxRAiYiI5KbISDCG+Q/f5HhvjOORLmll78UzmTNnDh06dKBx48ZMnTqV22+/nebNm/NK3CZGjx5NQECAR3VJwVAAJSIikpvcZAknMpIdO3bw22+/AXDfffdx6NAhXn75ZWJiYpg3bx4VK1bMOO2XRV1SsLSIXERExAM5TUuQlJTEokWLuPCPf3D//v2k7ghrAX77Dc6ehapVc7Wtkvc0AiUiIpIHzp07y7Sb/krNmjXp378/L/j68vLEifxt8nLHAelHkzyYqlvQbXD+/gDJkgIoERERD6Vf/J2q73tRaaNTZ8+eZfbs2XTs2JHVq9cQEXQjnTp1YunSpezevZuxY8fi51c8c8UeTNUt7D4kD36R5JSm8ERERDzkWJ80I1P56dOneeSRR/jkk084deoU1113HcHtgqlWrRoLHhub6Xhv96NTBvHCx+MAyhjjC6wFDllr7zLGVAbmA0HAPqCPtfZEXjRSREQkp3JzS5X04uPj+fjjj1m7xYdHfvmC539bRa9evRg8eDDt27fHx8f9JE9W+9Fps9+iwZsRqJHAdqC88/0zwDJr7URjzDPO95nDbBERkSIkU8AVGQkTJjA/9QBjAHjbx4fnU1K4/qEpjNqyjKEnT1KhQoVs688ukNNmv0WDR2ugjDG1gG5A+snfu4FZztezgJ652jIREZFc4mrtksciI9m/bx83PvMJAAbwr1yZ+MceY+PGjYSFhQF4FDxlZ/6wtpquKyI8XUQ+CRgDpKQrC7TWxgI4n3UPpoiIFErebKkCjoDr/PnzzJs3j9tvv53g4GD2798PwPz58zl8+DCTKlakWfPmSnJ5jco2gDLG3AUctdZG5+QExpiHjDFrjTFrjx07lpMqRERE8k1iYiK9F8+kRo0a9OvXj927dxMREUGbNjeyoNtg+vTpQ4kSJZTk8hrnyQhUO6CHMWYfMA+41RjzMRBnjKkO4Hw+6urL1tpp1tpwa214QEBALjVbREQkG15sg3LkyBFef/11mjdvTnS0Y7yga9euLF26lN9//52IiAhKlCipVAKSxlhrPT/YmI7AKOddeK8C8ekWkVe21o7J6vvh4eF27dq1WR0iIiKSq/q+F+UIoi779673Oz8THx9P6V+msWTJEp69dIlIVxVERGQ5qtT3vSh6fTWd3l9nTm8gRZsxJtpaG+7qsyvJAzUR+NQY8yBwAHTTgIiIFG7WWn799VdmzZpF1JnruHjxIsU2bGD06NH0HTgQGjVyG3C5M39YW9DC72uOVwGUtXY5sNz5Oh7onPtNEhERcc9dXqes8j3Nu2MQv//738yaNYtdu3ZRqlQprh82hWqB1fh29n58fX3zvuFyVdFWLiIiclU6c+YMs2fPZuOmjTxRqSHjx4+nWrVqzJgxgyNHjtCoYSOGrlzkMnjSvnOSHW3lIiIiV41eX01neYMkZs2axcKFC0lMTKTuA/8hKCiIVb/9Rr169TIc725rFiWzlOwogBIRkQKTk+k4cCbGTPfZli1b2Lt3L70Xz8Qsnkm5cuXo06cPgwYN4uabb85yW5XLKZGleEJTeCIiUuT0XjyTmJgYXn31VZo3b07Tpk05ePAAAB9//DFHjhxhxowZrvek8yK9gYg7CqBERKRAudtmxVX5yZMniY2NBaBOnTqMGTOGx+LjsUDsJ+MA6H/ffZQuU8Z9QKQEmJILFECJiEie6/teVNq03OXcbbOSWp6UlMR///tf5jdqRMVKlVgx4R4AUqzFAkOGDFFAJPlOa6BERMRrOV275K2hQ4eyYMECEhISCAwMJGrkSHbV+gvfjO7qcZ6mrCzoNliLxSVHNAIlIiL5IsOUnJt1SInh4RnK358+nZMJCey57z5iYmKYNGkS5cqVc3sOb9MPaGsWySkFUCIikiPerF2Cy6bqLluH9M8JEwhp3Jhy0dH4FStGyIhpAJw9cwas5brZsylW7M9JE3eBkjcB0fxhbXXHneSYAigREcmR7NYuZWXv3r1MnDgxbePeyMhIAgICePvtt4mNjaVJkyYAlC5d2uX3NXIkBU1roERExK0rXtMUGQkTJjA/9b0xAMwCJgD1h01lZvvexMydRI0aNdJ9cbfb9Unu2qLRJMlPGoESERHPucuh1LGj6zVNiYlMnTKFBg+/7SgGWoaFUfrll9m7dy8tWrTg//7+5GXBk4NGmaQwyzaAMsaUNMasNsZsNMZsNcZMcJZXNsYsNcbsdj5XyvvmiohIXsgqzUCmxd+uUgYsX56h/P1p0+h8661U+M9/GDFiBBcvXgRg165dREdHM2bMGIKCgrQOSYosT0agkoBbrbXNgVDgDmNMG+AZYJm1tj6wzPleRESuMp6saTpx4gSzZs1i8+bNADz00EMcPHiQ8ePHs2XLFsLDw1nQbTD169f36JwKrKSwyzaAsg6Jzrd+zocF7sYxjY3zuWdeNFBERPKHu7vn3Jl/5/3MmDGDO++8k8DAQO6//37Onj3DtHZ/Zd26dezcuZN//vOfhISEAJqSk6uLsR4kIjPG+ALRwPXAVGvtWGPMSWttxXTHnLDWZprGM8Y8BDwEUKdOnZb79+/PrbaLiEgu6ftelGP9Uuq/Cc7F35dLfPppZl93HW9uMSScPMmRT8ZRr1497rnnHu655x7e2JACaEG3XB2MMdHW2nCXn3kSQKWrqCLwGfAYsNKTACq98PBwu3btWo/PJyIi+SNTAHVZ+VtvvsmiRYv46aefsNZyww030KtXL3r16kVoaCjGeXedyNUkqwDKqzQG1tqTxpjlwB1AnDGmurU21hhTHTh65U0VEZF85SbNwMmRI5lRuzbrd5cCYOTIkTRp0oSIiAjuueceQkJCFDTJNc2Tu/ACnCNPGGNKAbcBO4AvgUHOwwYBX+RRG0VErmlZ3SF3xXVddlfdxJdeIrxlSyq9+SajRo0iJSWF6Tffw44dO9i8eTMRERE0adJEwZNc8zy5C6868IMxZhOwBlhqrf0amAjcbozZDdzufC8iIjmUm4GSJ6y1rF+/noiICFKXV4wbNw5fX19eeeUVfvvtN1q2bMnS+56mQYMG+dYukaIg2yk8a+0moIWL8nigc140SkREMur11XTIhYXZ1lq6L5zK41vn8sUXX3DgwAF8fHy4/qEpzLilF/s/fp06deqkHT9/WL0rPqfI1UiZyEVE8pnHSSvT8SQXk7tzJCYmsmjRIgYOHMiqVasYsOwT3n//fUJDQ5k5cyZHjhwhNDSU7/o/lSF4EhH3tBeeiEgh4giUZlxxPcnJyXRfOJXuX/+bpUuXkpSURKVKlag9qBMAf/zxB2XKlEk7fv6wgCs+p8i1RCNQIiIFwKOkle72nYuMBDKPZO3Zs4fXXnuNm2++mVWrVvHAj5+yefNmHn74YfYOGsTxEyfYOGkwAGXKls1Ql4h4RyNQIiIFIMNIk5tUAkREOO6Qc5OjCSynTp1m/PjxfPHFF2zduhWA0NBQgoKCANi7d++fd8x9+GEWdYmINzQCJSKSRzy+q87dBr0uRocSEhJYsGABgwYNYtWqKDp/9Covv/wyVapUYdKkSZwYOZL1Gzbwy0v9ADA+PhppEskDGoESEckvWY00ZRHgnDt3jhm39OKTzp1ZsWIFFy9epHLlytQc2IFRW5bx4PHjVKqUbiOISZOyHGla0G0wvXPrN4lcozQCJSKSXzwYaVrQbTDJycn88MMPPP20I//S6tWrGV+rJXFxcTz99NP89NNPxMXF0ahhI4CMwZMHtKmvyJXTCJSIyGVSp91yY0NcT/M3/fHHH8TFxfHP625iSJUqnDp1iuLFi9OpUyfuuqks3bp1Izj4GcfBkZFwyy3ZjmS5GmnSJr8iuUMBlIiIh3ISWLlLS7Cg22DqRUezZMkSvvnmG6KiorDWUq1aNXr37s1dd93FbbfdRtmyZTNXGhkJkZHZLghf2H2IpupE8ogCKBERF3Ir83d6x44dY+nSpezYkcRT/o2JCXds8t6yZUuef/55unfvTosWLfDxufLVFRppEslbCqBERFxwN3LkUWDlZrH420Ak4O/vT9euXbnjo4/o0qULgYGBOW6nFoSLFAwFUCIiXsguU/jhw4f5v7p1WdKnDz+XaEXM7NH4+vhw4403cuedd7L6jjsICwvD19c3V9qjaTqRgpFtAGWMqQ18BFQDUoBp1to3jTGVgflAELAP6GOtPZF3TRUR8Z5X65ZykGbgwoULdP/PMo4fP86FJa+wadMmAKpXr07Ve+8EHFN3lStXzvmPcEPTdCIFx5OJ9ovA09baRkAbYLgxpjHwDLDMWlsfWOZ8LyJSJLhMcukuzQC43FJlboMG+Pv7s3HjRmJiYqhcuTITJ05kw4YNHDp0iAYNGrCg2+A8CZ5EpGBlOwJlrY0FYp2vTxtjtgM1gbuBjs7DZgHLgbF50koRkWxkNdJ0pQvCY4cNY9n11/NqdDIbJw3GOS7FdZcu0b9/f3bXDmHYqs/o88MPmb6rKTaRq5NXt3oYY4KAFsCvQKAzuEoNsqq6+c5Dxpi1xpi1x44du8Lmisi1zuPtUdJxrFvKzN2GvpcuXeKjW/vx5JNP0qRJE2rUqMGAAQM4fjwegGnTpvH777+zZ88e3n33XapUqUKfbz7IVM/8YW01zSZylfJ4EbkxpiywCHjCWnsqbXPKbFhrpwHTAMLDw7V7pYgUGqkLwi9evMiaNWv4/vvvWbp0Kbtrd2NlYDNOvhPJLbfcwsCBA7ntttt4eU0SC+IHM3To0IJuuogUMI9GoIwxfjiCpznW2v86i+OMMdWdn1cHjuZNE0VEPJNhRCky0uW6JSIjsdZy9uxZAHr27Im/vz833XQTERERnD17lkG1TzDnwVacOHGCpUuXMmbMGMLCwoDLtkHJ4hwicnUz1k0G27QDHENNs4Dj1ton0pW/CsRbaycaY54BKltrx2RVV3h4uF27du2Vt1pErll934ui11fT6f31jEzlrrJyp5bv2L6d5cuX4z95Mr23bctU79Zevaj27rv4+/vnqE1ZZQQXkaLJGBNtrQ139ZknU3jtgAHAZmPMBmfZP4CJwKfGmAeBA6B1kiKSP7LLxWStZffu3Sxfvpzt2x1/zTVq5Nh4t1atWnw1YAD7r/srP0b+LS3oCcnzVovI1cSTu/BWAu4WPHXO3eaIiHjJRe4mA3wCTABqD3qdd27swftDutOpUyfq1auHMcbrhejZUUZwkWvLlW+4JCLXpJzcDXdF3Kw3+uyzz6hdqxbV+r0EQLXAQPrdey/V332XnTt30rZtW5Y/8AxDhgzhuuuuI/0NMAu6Dc615mVYGyUiVz1t5SIibnmVxTsPz52SksKWv/2NnwICeHd3STa/OSRtWDwgNpaOHTsSW78+ALGxsRmCpPk3uD9HbuVoUqoCkWuPAigRyTFvElR6E4wlJSVx6lQCJ08m0K3bi/z8888kJCQAUOf+1wGYOnUqHTp0oHHjxmlTcgu6Daa3hylWFPSIyJXQFJ6IZMldsklwn6DSWwkJCSxZsoTx48fTvn17KlSowPr1G7jny/f5/fff6dOnDx999BF79+6lTZu2LOg2mEcffZSQkJAMo02aRhOR/KIRKBHJUnZ3vHkjdcQqNjaWlStX8tNPP/HN+RtITEwkbu44fH19CQsLY/jw4WyoHMKoueMYlSk1QKzLqTeNKIlIflIAJSLecXHXGwARERAZmWmqLjk5OW1z3d6LZxIUtIz9+/cDULp0aWrf/zp169Zlzvff06ZNG8qUKQPgdoG6AiURKQw0hScimWWVYTsyEqyl77urHJ9Z63g4s28nJ1/gjz/+YOzYsbRv357y5cvTunVr9uzZA0Dr1q154403+PXXXzl58iTNmzVn1Obv6dy5syN4UnZvESkCss1EnpuUiVwkZwrqbrisMmynfrYuOpqoqChWrVpFVFQUZ9s8BMDxhc8TFhZGJHDHr79mrjzdiFVWGcSV3VtECsqVZiIXEcFay4EDB1izZg2rV69mQ2Iwrze9jVEtWwJQo0YN2rZtS+x11/HIL1/Q69QpSpYsmfZ9BUQicjXRFJ6IuEyKGR8fz/Hjx5l+8z10796datWqERQURO/evXnzzTepsPYDDnRqzNy5c9m3bx8xMTEsXLiQWrVqcd/3czIETy55MFWXm4kuRURyk0agRK5Qfk2v5VXOJYCUlEucPp3IG2+8kTbC9PvvvxPY7yU21w7Hf+Ns7rzzTlq3bk3r1q1p2rQpJUqU8Po3ZNjuxLmeKquRqdxKdCkiktuyDaCMMTOBu4Cj1tomzrLKwHwgCNgH9LHWnsi7ZoqIq3QC3gZKfd+LIiUlhTHhxYmOjiY6OprVq1cTF9IPgP+bO47atWvTunVrhg0bRqtWrWjZsiXlyz+TfeXZ3J0H3gVEuttORAozT0agPgSmAB+lK3sGWGatnWiMecb5fmzuN09EcqrXV9M5c18zNmzYwLp161i3bh1ri4Vx9uwZFj46DoBKlSrRunVrStaty/DVX9ElNpZq1arl7ITZjChlFRBpI14RKWqyXQNlrV0BHL+s+G5glvP1LKBn7jZLpGjJKlu3NzKtRfLilv6EhASWL1/OG2+8wfYd2+m9eCblypXj5ptv5vHHH2fx4sWUKFGCf+5fw8KFC9m7dy/x8fEsWbKEoKAgBv5vbs6DpyukDOIiUtTkdA1UoLU2FsBaG2uMqZqLbRIpcnIzW3cGLkZ1rLUcPnyYTd9+y4EDpxjw/Rzqv7Y9Lc8S/Llf3PPPO1IJtGzZkho1anDvtF8YOnUYrFyU+21Nx5sRJU3ViUhRlOd34RljHjLGrDXGrD127Fhen06kUHF1d1tW5ZBxNCspKYn169dz5MgRADp37kxAQAC1atXiL3/5C3v37uXR1V/RrFkzXnzxRXb9/e9YYP+HTwMQOWECPe6+m5rvv59hz7g0eZS0UiNKInK1y2kAFWeMqQ7gfD7q7kBr7TRrbbi1NjwgICCHpxP5U1bBR77Wk4vBh7WW2NhYTpw4Tu/FM+nfvz9NmjShTJkyhIWFsXPnTl5vehunTp2iZ8+evPXWW/z444+0a9cOgEWLFjF+/Hjqz5njOku4s32Z2uo8xl1W8ZyYP6ytRpVE5KqX0wDqS2CQ8/Ug4IvcaY5IEZLNliapLl8flZCQwKlTp7hj7iSeeOIJbr/9dgIDA6lRowabNm0GYMWKFQQFBTFmzBjmzZtHq1atWD18AmvWrGH69Ok8Fh9P+w4dWDSivaPS7II3D9sqIiKe8SSNwVygI1DFGBMDRAATgU+NMQ8CB0A30Ej+cpUTKbfyMeVWPYmJiZw+fZrei2cyalQltm7dypYtW4iJiSGw30t8++OnlF5disaNG/N+zZrcfewYzHXcHXcwJgZiYiA8HPr2pe/llXuQQ8nbO9t0J5yIiOeyDaCstf3cfNQ5l9sihVBeJ4nMaf25tWg7N5JTpqSkMOf2+0iZPZutW7emBUr79u0jsN9LAEyZMoVGjRrRoUMHQkJCWOZIqUZiYiI+Pj4ZzpFb2524y7nkLlBS0koREc8pE7lcVbwJiMB9IHZ5PdZaLly4wNmzZ3nnnXfYsWNH2iOp3SP8VCWEuIED8fPzo0GDBrxapgy9IG1E6XxSEmzYABUqwJw5jHPW6+Pr63iRLtmkt1wFRFkFpK4CJa1ZEhHxjgIoAbIeCfJmuiwnI0oeBz0eZLq+0pGppKQkzp49Q+/FM/nXv+qxc+fOtECp9F3/YNTm73l0yzLKlClDw4YNueWWW2jY8CINGjSgyXPbuP766/Hz80urz92IUm5OvSm7t4hI/lMAVYjkx55qOTlHnuU48rZ+D9b9uHL5b7703HP4vvhipkDsrUqVeDIhgYC+/wLg2WefpVatWjRs2JBBgwaxoXJ9Rs0dx70HD1KzZk3XaQFygQIiEZHCL8/zQMnVy1327TzLyu2Om3QC8Y89xjfffMOhQ4fYs2cPd955J/Xr16fESy9hgGrO9UnlypalRWgo1atX51JKCkec024Wx2Lupe3aMXnyZGrUqAFArVq1vAqeFnQb7FW5iIgUfldNAJVbuYHyg6dJFPNbhnN7kOPIMXKUmbvyDK4wh9KCboM5fvw40dHRLGzShFdfeYWwpx27C11Xrx7FfH2pMmUK3bp1Y8+ePRw5coSjR48SFhbG2LFj+eCDDwgNDQXg1KlTrF+/nt5bt3qXQ8nDtrpLKumqXDmURESKBk3hFTJ5PV0G7tccZTh3DqfLPOZB/Skpl/jr59P4umY8e/fuTXtsCriVlZUactjfP8PxNQe8CkDr1q35+9//zvXXX0/9+vV5bd1F+i2ZRe/o6AzHf/telGO9UXajSVfQF+6CIQVJIiJF21UVQHl7B1Z+rDlyx9u2eiur33ZFQZq7hdwdOsCPP2a5wDs9ay3x8fEkJiYCMHnyZA4ePMiBAwfSAiWf255iwXezMd/NBqBUqVIEBwdTotadVKxQkadff52goCCCg4MJDg5m2PztLDg+mLlzM/42v81Rbn+zt7f6i4iIwFUWQOXH6E1uyTTak83dZe5ccRDowbkzBBPZjMaklieePp0WEB2cPp33fytDUlISVTZ97Cg7eJDz588T2O8lXmvSmdGPP06JEiWoVasWwcHB9OzZk80BwQBERUURHBxM1apVs117lFsLsBVYiYhIVvI1gPr92Jn8PJ1HciOR4hUfn0fTZRl+W1aBkrVZnjt9MJGcnMyRI0c4ffoUAFOnTuXw4cNpjz117gKgXLlyGeoI7PcSY7f9wKelztCiRQt69OhB7dq1+TKxHv8LCyNu4CcEBAQ4AiRnW+F9ANq0bftnW7MIKDP1cw4D05wEViIicm0p+iNQVzB6A/k8apXDtuZKtu5sgrSUlEsA/PLLL8TFxXHkyBEOHz5MeWdg1OJdx/PRo459o9NGjkaMwNfXl+rVq1OjRg1KNSjFe217MvHuNtSuXZvatWtTp04dRn97iCfnjuPJy8470lXDcyugzOXAVOuWREQkVb4GUJUSjuV+pXkwepNbSSUzHZ8H+5e5a1Oqbdu2ERcXx9GjR4mLi2Pv4SoA3H333RnKy939nCMgavtnPT4+PgQGBlK9enVq1apF69atqVGjBjVq1ODTP2rwQ8uWHLlvDgEBARm2I4HMd5cZc9jLXyUiIlJ45XMAFZ+fp3PvCkatPN36I7vj3XE1RWSt5W9fTGNLu3LEx8dnePx2oha9F8+kR49jxMfH02/nTkbEx6f9tsYhITQGIoEJQLW/v8R/mndx7NMWGMj1119PYGAgUaXq8VWD4XzzytNUrVqVatWqERgYSLFiri+RoZ7+oCscIcytNUdauyQiIrnpigIoY8wdwJuALzDdWjsxV1qVQx7/I5kHo1ZZBUoXLlwgISGBhIQETp48yYkTJ5jV6V4uzpiRVpaQkMAOn1AuXrxIx47jOHnyJCdPniQ+Pp4y3cfz6ZJZmCWzMtVdvf/LAOzfvx9/f39+7NSJLf7+rKvYntUv92fe3LkEBgbSu2pVRgQGMnzRbn5p34GN+TUddYV9nVtrjrR2SUREclOOAyhjjC8wFbgdiAHWGGO+tNZuy+aLjmfnCIS3e6plNV3m7h9JT9YQWWtJSkri3LlzXLhwgT6LZ7L15vKcP3+eKlOmUPfDDzONonzfrh1ftGjBTr+WANx5550kJibSf/duHo6LSzu+eIkSBODorAk41g9tqtacuCFDnNUZypcvT8WKX1CxYkVshQrUrVuXZs2a4e/vT1SpIEf758/H398ff39/gmfNosKkSTBnLAAbN21y2a/33ntvht85f1gVt31Q2OTWmiOtXRIRkdxmbA5HX4wxbYFIa21X5/txANbal9x9J9wY+8/Fi0lJSUl7TN7q2I3+4RvOk5KSgrWWlJQUpu0pDcD9dU5ireXSpUskJyczJzaAlJQUupf5jeTkZJKTk7lw4QLLbFOstbQ6/XOG8uTkZHbUuIOUlBSqbPqYc+fOcf78ec6dO0fyLcN5Yv0Sxu/6ifPnz6e1M7DfSxyZO47Lb5i/vPyfPj48l5KS6XfOveEGvg4PZ1v1Lqx//X5efOEFKlasSMWKFalQoUKm53Llyl22hsgp7W60y6Sb/soqnUCvr6bT++vCkdahsLVHREQkO8aYaGttuKvPrmQKryZwMN37GOBGFyd/CHgIoCXQrVu3DJ8H9nuJUZu/p8+WZS7LH3BTPtpZboyhePHi+Pn54efnR4zz2c/PL608yb8TI9d9y2fl/ShfvjwlS5akVKlSbPX3Z06XATzWNTStrFSpUiw6URtwjPiULFmSMmXKUK5cOV74+TTMhfj4eMqWLUvx4sWBzEFMP+cjdRTo2WefzUH3Umimv3JLYWuPiIhITl1JAOUqo2Gmf+GttdOAaQD1yvvbX7//Fh8fH3x8fDDG8NwPfzBq7jju3LIFY0zaZ6O+iWHU3HHc8/vvaWXFixfn0YW7GDV3HCPOncPPzw9fX99sG9r3vSgee/8xHnMxSgPwyrABjoLISPjHP3jC+Xmfvn0dL5wjPqXXO7f+qFzZk/4B8mfxsqtzFLZpq8LWHhERkStxJQFUDFA73ftaQJb3qp+sVJXWrVtnKCuz2hHEhISEZCgv9YPjjr3g4OAM5cWK/Q5AyZIlc9DkjFwmXsxmxMfbDNW5NeqSVSCmkR0REZH8dSVroIoBu4DOwCFgDfB3a+1Wd98JDw+3a9eudbxxt77Huaeax+VZ3Q7vwRoiV7ydMivIPfVEREQkb2S1BsrFymXPWGsvAiOA/wO2A59mFTxlEhnp2ELk3VWpFToey5d7V55VLiF35/Aw/5Cn5g9rq+BJRETkGnJFeaCstd8A3+RSWwoVTYuJiIiIOzkegcpN7kZ7vC3PyTlc0YiSiIiIZKVQBFALu2feOy0n5Tk5h4iIiIi3cryIPCcyLCIXERERKcTyZBG5iIiIyLVKAZSIiIiIlxRAiYiIiHhJAZSIiIiIlxRAiYiIiHhJAZSIiIiIlxRAiYiIiHgpX/NAGWNOAzvz7YRFXxXgj4JuRBGjPvOO+st76jPvqL+8pz7zTl72V11rbYCrD65oL7wc2OkuIZVkZoxZq/7yjvrMO+ov76nPvKP+8p76zDsF1V+awhMRERHxkgIoERERES/ldwA1LZ/PV9Spv7ynPvOO+st76jPvqL+8pz7zToH0V74uIhcRERG5GmgKT0RERMRL+RJAGWPuMMbsNMbsMcY8kx/nLIqMMfuMMZuNMRuMMWudZZWNMUuNMbudz5UKup0FxRgz0xhz1BizJV2Z2/4xxoxzXnM7jTFdC6bVBctNn0UaYw45r7MNxpi/pPvsmu4zY0xtY8wPxpjtxpitxpiRznJdZy5k0V+6xtwwxpQ0xqw2xmx09tkEZ7muMRey6K+Cv8astXn6AHyB34B6QHFgI9A4r89bFB/APqDKZWWvAM84Xz8DvFzQ7SzA/mkPhAFbsusfoLHzWisBBDuvQd+C/g2FpM8igVEujr3m+wyoDoQ5X5cDdjn7RdeZd/2la8x9nxmgrPO1H/Ar0EbXmNf9VeDXWH6MQLUG9lhrf7fWXgDmAXfnw3mvFncDs5yvZwE9C64pBctauwI4flmxu/65G5hnrU2y1u4F9uC4Fq8pbvrMnWu+z6y1sdbadc7Xp4HtQE10nbmURX+5c033F4B1SHS+9XM+LLrGXMqiv9zJt/7KjwCqJnAw3fsYsv4P7Fpmge+MMdHGmIecZYHW2lhw/GUFVC2w1hVO7vpH113WRhhjNjmn+FKnCtRn6RhjgoAWOP6PV9dZNi7rL9A15pYxxtcYswE4Ciy11uoay4Kb/oICvsbyI4AyLsp0659r7ay1YcCdwHBjTPuCblARpuvOvXeA64BQIBZ43VmuPnMyxpQFFgFPWGtPZXWoi7Jrrs9c9JeusSxYay9Za0OBWkBrY0yTLA6/5vvMTX8V+DWWHwFUDFA73ftawOF8OG+RY6097Hw+CnyGY9gxzhhTHcD5fLTgWlgouesfXXduWGvjnH8hpQDv8+fwtvoMMMb44QgG5lhr/+ss1nXmhqv+0jXmGWvtSWA5cAe6xrKVvr8KwzWWHwHUGqC+MSbYGFMcuBf4Mh/OW6QYY8oYY8qlvga6AFtw9NUg52GDgC8KpoWFlrv++RK41xhTwhgTDNQHVhdA+wqd1L+knf6K4zoD9RnGGAPMALZba99I95GuMxfc9ZeuMfeMMQHGmIrO16WA24Ad6BpzyV1/FYZrLM83E7bWXjTGjAD+D8cdeTOttVvz+rxFUCDwmePvI4oBn1hrlxhj1gCfGmMeBA4AvQuwjQXKGDMX6AhUMcbEABHARFz0j7V2qzHmU2AbcBEYbq29VCANL0Bu+qyjMSYUx7D2PmAYqM+c2gEDgM3ONRcA/0DXmTvu+qufrjG3qgOzjDG+OAYxPrXWfm2MiULXmCvu+mt2QV9jykQuIiIi4iVlIhcRERHxkgIoERERES8pgBIRERHxkgIoERERES8pgBIRERHxkgIoEcl1xpiKxphH072vYYxZmEfn8jPGRGdzzP3GmCl5cX4RuTYpgBKRvFARSAugrLWHrbW98uhcNwOr8qhuERGXFECJSF6YCFxnjNlgjHnVGBNkjNkCaaNBnxtjvjLG7DXGjDDGPGWMWW+M+cUYU9l53HXGmCXOzbV/MsY0dHOuO4BvLy80xjxgjNlljPkRR8LH1PLuxphfnef73hgTaIzxMcbsNsYEOI/xMcbsMcZUMcb0NsZsMcZsNMasyO2OEpGiSQGUiOSFZ4DfrLWh1trRLj5vAvwdx/5V/wLOWmtbAFHAQOcx04DHrLUtgVHA227O1QnH/lhpnNs8TMARON0ONE738UqgjfN884Axzv20Pgb6O4+5Ddhorf0DeB7oaq1tDvTw7OeLyNUuz7dyERFx4Qdr7WngtDEmAfjKWb4ZaGaMKQvcBCxwbm8EUOLySowxNYDj1tqzl310I7DcWnvMedx84AbnZ7WA+c4gqziw11k+E8f+Y5OAwcAHzvKfgQ+d20Okbi4sItc4jUCJSEFISvc6Jd37FBz/Y+cDnHSOYKU+Grmo504c+2y64m6fqsnAFGttUxz7Z5UEsNYeBOKMMbfiCMC+dZY/DDyLY4f3DcYYfw9/o4hcxRRAiUheOA2Uy+mXrbWngL3GmN4AxqG5i0Ndrn8CfsWxabK/McaPjJtwVwAOOV8Puux703FM5X2augGpMeY6a+2v1trngT9wBFIico1TACUiuc5aGw/87Fx8/WoOq+kPPGiM2QhsBe5O/6Fzd/b61todLs4fC0TiWFP1PbAu3ceROKYGf8IREKX3JVCWP6fvAF41xmx2LoJfAWzM4e8RkauIsdbdKLeISOFljLkZuM85xZZbdYYD/7HW3pJbdYrI1UkBlIgIYIx5BngE6G+tXVnQ7RGRwk0BlIiIiIiXtAZKRERExEsKoERERES8pABKRERExEsKoERERES8pABKRERExEsKoERERES89P8u9voCzt3XUAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# time driver every day\n",
    "tdriver = np.arange(0,365,1,dtype=np.int)\n",
    "\n",
    "# get the parameters we iolved for\n",
    "p = np.array([p0min,p1min])\n",
    "print(p)\n",
    "\n",
    "# forward model at all time points\n",
    "# noit just the measurement points\n",
    "output  = model(tdriver,p)\n",
    "\n",
    "# plot\n",
    "fig, axs = plt.subplots(1,1,figsize=(10,3))\n",
    "axs.set_xlim(0,365)\n",
    "axs.plot(tdriver,output,'k',label='modelled values')\n",
    "axs.errorbar(tmdriver,measure,yerr=std,ls='none')\n",
    "axs.plot(tmdriver,measure,'r+',label='measured values')\n",
    "# set legend now\n",
    "axs.legend(loc='best')\n",
    "axs.set_xlabel(f'time / days')\n",
    "\n",
    "print(f'measurements: tmdriver shape {tmdriver.shape}')\n",
    "print(f'model output: tdriver shape  {tdriver.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parameter estimation code is effective and quite fast in this case. \n",
    "We are using quite a sparse LUT (132 points) in 2-D, but the model is able to mimic the (pseudo) observations very well, even with rather a quantised LUT. We can see from the RMSE image plot above, and the value of RMSE we obtained, that this is likely a good solution for the model. We know from that plot also that the uncertainty in parameter 1 is high. A more sophisticated analysis would take into account the parameter uncertainty in producing the modelled outputs (i.e. put error bars on the model output).\n",
    "\n",
    "When we forward model using the parameters we solved for, we see that the solution \n",
    "found gives a good fit to the observations, within their error bars. This further informs us\n",
    "that the sensitivity to  model parameter p1 is quite low. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LUT inversion\n",
    "\n",
    "This approach is called a Look-up table (LUT) inversion. It has the advantage of being quite fast if the total number of samples in the LUT can be kept down in number. This means that the limits to the problem need to be carefully considered: if your LUT inversion produces a supposed optimum parameter value that is on the bounds of the parameter space, then this can often be quite suspect: it may be that you just haven't sampled over a large-enough parameter space. The result is quantised to the LUT spacing if you use the simple approach here, but that will be fine for many applications. This is really only an appropriate method if you have a small number of parameters that you are solving for: i.e. a 1-, 2- or perhaps 3-Dimensional problem. If your model has more parameters, you may have to adopt a multi-pass strategy for parameter searching, or use a method other than LUT inversion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 1\n",
    "\n",
    "In a file `lut_RMSE.py` do the following:\n",
    "\n",
    "        import numpy as np\n",
    "        # define the min and max and step for the grid we want\n",
    "        p0min,p0max,p0step = 0.0,10.0,0.05\n",
    "        p1min,p1max,p1step = 0.0,0.001,0.000005\n",
    "\n",
    "        gridp0,gridp1 = np.mgrid[p0min:p0max+p0step:p0step,\\\n",
    "                                 p1min:p1max+p1step:p1step]\n",
    "\n",
    "\n",
    "* Write a function `gen_lut` to return a 2D parameter (Look up table -- LUT) grid using `np.mgrid` as above as `param = [gridp0,gridp1]`\n",
    "\n",
    "        # simple model \n",
    "        def model(driver,param):\n",
    "            '''2-parameter quadratic model with noise'''\n",
    "            return param[0] + param[1] * driver * driver\n",
    "          \n",
    "* Write a function `model` to describe the model we will be using from the code above\n",
    "            \n",
    "        # code to use\n",
    "        # time driver every 4 days for measurement    \n",
    "        tmdriver = np.arange(0,365,4,dtype=np.int)\n",
    "        # generate a pseudo-measurement\n",
    "        p0 = np.array([5.0,0.0005])\n",
    "        measure = model(tmdriver,p0) + 5*(np.random.random(tmdriver.shape)-0.5)\n",
    "        # just make up some weights for this exercise\n",
    "        measure_weight = (2 + np.random.random(tmdriver.shape))/4\n",
    "        \n",
    "* Write a function `gen_meas` to generate a pseudo-measurement based on the model and some noise. It should print the value of the parameters used in the model, and return `tmdriver, measure, measure_weight` corresponding to:\n",
    "\n",
    "        * tmdriver:       array of (Nm,) floats of the day of year on which to do modelling\n",
    "        * measure:        array of (Nm,) floats of measurements over sampled days of the year\n",
    "        * measure_weight: array of (Nm,) floats of the weights associated with the measurements\n",
    "\n",
    "* Write a function `lut_RMSE` that takes as inputs:\n",
    "\n",
    "        * `param`:          list of `[p0,p1]` with `p0` and `p1` being arrays of shape `(Np0,Np1)` representing a the LUT grid over parameter space\n",
    "        * `tmdriver`:       array of (Nm,) integers: the days on which the measurements occur \n",
    "        * `measure:`        array of (Nm,) floats of measurements over sampled days of the year\n",
    "        * `measure_weight`: array of (Nm,) floats of the weights associated with the measurements\n",
    "    \n",
    " That runs the model `model(tmdriver,param)`, calculates the weighted RMSE between the measurements and the modelled values for each parameter pair, and returns a grid of shape `(Np0,Np1)` values of RMSE associated with each parameter pair.\n",
    " \n",
    " * Write a function `runner()` that \n",
    "    * generates tmdriver, the array of (92,) floats for every 4 day of year on which to do modelling\n",
    "    * gets a LUT `param` from `gen_lut`\n",
    "    * gets a pseudo-measurement from `gen_meas`\n",
    "    * gets a 2-D array of RMSE corresponding to the parameter grid\n",
    "    * calculated and prints the value of the parameters corresponding to the minimum RMSE,\n",
    "    * returns the RMSE array, the LUT, and the measurements\n",
    " \n",
    "* Run `runner()` in a notebook\n",
    "* Plot the RMSE values returned from this as an image\n",
    "* Verify that you have identified the minimum RMSE\n",
    "* Set different parameters in `gen_meas` to generate a different pseudo-measurement and repeat the process.\n",
    "* Comment on the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original parameters: [0.4, 0.0002]\n",
      "min rmse\n",
      "2.372352991393801\n",
      "index: 2452: 0.6000000000000001,0.0002\n",
      "parameters: 0.6000000000000001 0.0002\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "# run your own script \n",
    "!geog0111/lut_RMSE.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original parameters: [0.4, 0.0002]\n",
      "min rmse\n",
      "2.446801263996164\n",
      "index: 41: 0.0,0.00020500000000000002\n",
      "parameters: 0.0 0.00020500000000000002\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "import numpy as np\n",
    "# Run runner() in a notebook\n",
    "from geog0111.lut_RMSE import runner, model, gen_lut\n",
    "RMSE,param,(measure,measure_weight,tmdriver) = runner()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index: 41: 0.0,0.00020500000000000002\n",
      "parameters: 0.0 0.00020500000000000002\n"
     ]
    }
   ],
   "source": [
    "# confirm: same as in runner?\n",
    "# use argmin to find min, but need to flatten/reshape arrays first\n",
    "p0,p1 = param\n",
    "p0_ = np.ravel(p0)\n",
    "p1_ = np.ravel(p1)\n",
    "# min over time axis\n",
    "imin = np.argmin(RMSE,axis=0)\n",
    "\n",
    "print(f'index: {imin}: {p0_[imin]},{p1_[imin]}')\n",
    "# back to 2D\n",
    "ip0min,ip1min = np.unravel_index(imin,p0.shape)\n",
    "p0min = p0[ip0min,ip1min]\n",
    "p1min = p1[ip0min,ip1min]\n",
    "\n",
    "p = np.array([p0min,p1min])\n",
    "print(f'parameters: {p[0]} {p[1]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fbaf040d4d0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Plot the reshaped RMSE values returned from this as an image\n",
    "\n",
    "# plot it\n",
    "fig, axs = plt.subplots(1,1,figsize=(10,8))\n",
    "im = axs.imshow(RMSE.reshape(p0.shape),interpolation=\"nearest\",\\\n",
    "                vmax=10,cmap=plt.cm.inferno_r)\n",
    "fig.colorbar(im, ax=axs)\n",
    "axs.set_xlabel('p0')\n",
    "axs.set_ylabel('p1')\n",
    "plt.plot([ip1min],[ip0min],'r+',label=\"minimum RMSE\")\n",
    "axs.legend(loc='best')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original parameters: [0.7, 0.0005]\n",
      "min rmse\n",
      "2.034386901987606\n",
      "index: 1909: 0.45,0.0005\n",
      "parameters: 0.45 0.0005\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fbaf8941750>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from geog0111.lut_RMSE import gen_meas,model,lut_RMSE\n",
    "\n",
    "# change the original parameters \n",
    "tdriver = np.arange(0,365,1,dtype=np.int)\n",
    "# gets a LUT `param` from `gen_lut`\n",
    "param = gen_lut()\n",
    "# gets a pseudo-measurement from `gen_meas`\n",
    "tmdriver,measure,measure_weight = gen_meas(p0=[0.7,0.0005])\n",
    "# gets a 2-D array of RMSE corresponding to the parameter grid\n",
    "RMSE = lut_RMSE(param,tmdriver,measure,measure_weight)\n",
    "# calculated and prints the value of the parameters corresponding to the minimum RMSE,\n",
    "min_rmse = RMSE.min()\n",
    "print(f'min rmse\\n{min_rmse}')\n",
    "\n",
    "# use argmin to find min, but need to flatten/reshape arrays first\n",
    "p0,p1 = param\n",
    "p0_ = np.ravel(p0)\n",
    "p1_ = np.ravel(p1)\n",
    "# min over time axis\n",
    "imin = np.argmin(RMSE,axis=0)\n",
    "\n",
    "print(f'index: {imin}: {p0_[imin]},{p1_[imin]}')\n",
    "# back to 2D\n",
    "ip0min,ip1min = np.unravel_index(imin,p0.shape)\n",
    "p0min = p0[ip0min,ip1min]\n",
    "p1min = p1[ip0min,ip1min]\n",
    "\n",
    "p = np.array([p0min,p1min])\n",
    "print(f'parameters: {p[0]} {p[1]}')\n",
    "\n",
    "\n",
    "min_rmse = RMSE.min()\n",
    "\n",
    "fig, axs = plt.subplots(1,1,figsize=(10,8))\n",
    "im = axs.imshow(RMSE.reshape(p0.shape),interpolation=\"nearest\",\\\n",
    "                vmax=10,cmap=plt.cm.inferno_r)\n",
    "fig.colorbar(im, ax=axs)\n",
    "axs.set_xlabel('p0')\n",
    "axs.set_ylabel('p1')\n",
    "plt.plot([ip1min],[ip0min],'r+',label=\"minimum RMSE\")\n",
    "axs.legend(loc='best')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.45   0.0005]\n",
      "measurements: tmdriver shape (92,)\n",
      "model output: tdriver shape  (365,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# error bars\n",
    "std = 1./np.sqrt(measure_weight) * 1.96\n",
    "\n",
    "# time driver every day\n",
    "tdriver = np.arange(0,365,1,dtype=np.int)\n",
    "# get the parameters we siolved for\n",
    "p = np.array([p0min,p1min])\n",
    "print(p)\n",
    "output  = model(tdriver,p)\n",
    "\n",
    "# plot\n",
    "fig, axs = plt.subplots(1,1,figsize=(10,3))\n",
    "axs.set_xlim(0,365)\n",
    "axs.plot(tdriver,output,'k',label='modelled values')\n",
    "axs.errorbar(tmdriver,measure,yerr=std,ls='none')\n",
    "axs.plot(tmdriver,measure,'r+',label='measured values')\n",
    "# set legend now\n",
    "axs.legend(loc='best')\n",
    "axs.set_xlabel(f'time / days')\n",
    "\n",
    "print(f'measurements: tmdriver shape {tmdriver.shape}')\n",
    "print(f'model output: tdriver shape  {tdriver.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true,
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "We confirm the findings above, but are now able to see the form of the error surface in much greater detail. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Comment on the results\n",
    "\n",
    "msg = '''\n",
    "We confirm the findings above, but are now able to see the form of the error surface in much greater detail. \n",
    "'''\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this notebook, we have discussed some generic aspects of models. We note that they typically have some set of driving data (even if that is just time, as in the example here), and a set of parameters that control the model response. \n",
    "\n",
    "We have seen how we can apply the concepts we learned in the [`numpy`](032_More_numpy.ipynb#032-More-numpy) sessions to build a parameter LUT and rapidly calculate a goodness of fit measure between some set of observations and the model output. We have seen how to use this to provide an estimate of the model parameters. This is known as model calibration. \n",
    "\n",
    "Technically, we have seen how we need to reconcile the dimensions of the parameter LUT and the model outputs in `numpy` using `np.newaxis` so we can calculate the model outputs for all parameters in the LUT efficiently, all at once. We have seen that parameter estimation in this way can be effective, but may be limited to a relatively small-dimensional problem. If we have a larger number of parameters, we may need to devise other strategies for parameter estimation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "[<img src=\"images/noun_post_2109127.svg\" width=\"50\" align='right'>](051_Phenology_model.ipynb)\n",
    "[<img src=\"images/noun_pre_2109128.svg\" width=\"50\" align='right'>](043_Weighted_interpolation.ipynb)\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda env:geog0111-geog0111",
   "language": "python",
   "name": "conda-env-geog0111-geog0111-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}