{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ex4 practical exercises for [Example Sheet 4](https://www.cl.cam.ac.uk/teaching/current/DataSci/ex/ex4.pdf).\n",
    "\n",
    "The example sheet asks you to implement the skeleton functions given below.\n",
    "To test your answers on [Moodle](https://www.cl.cam.ac.uk/teaching/current/DataSci/redirect/ex4moodle.html),\n",
    "please upload either a Jupyter notebook called `ex4.ipynb` or a plain Python file called `ex4.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**fit_mrrw.** We have a dataset $x_0,x_1,\\dots,x_n$, which we wish to model as\n",
    "$$\n",
    "X_i = \\mu + \\lambda(X_{i-1}-\\mu) + N(0,\\sigma^2).\n",
    "$$\n",
    "Find maximum likelihood estimates for the three parameters.\n",
    "\n",
    "<img src=\"res/mrrw.svg\" style=\"height:6em\">\n",
    "\n",
    "```\n",
    "def fit_mrrw(x):\n",
    "    # Input: x a numpy vector\n",
    "    # TODO: find maximum likelihood estimates\n",
    "    return (μ, λ, σ)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**fit_climate0, fit_climate1, test_climate0.** Consider a dataset of average November temperatures in Cambridge, $(t_i,\\text{temp}_i)$, giving the year and the temperature. The records are in increasing order of year and there are no gaps. Here are two possible models:\n",
    "\\begin{align*}\n",
    "&\\text{Model }H_0:\\qquad \\text{Temp}_i = \\alpha+\\gamma(t_i-2000)+N(0,\\sigma^2)\\\\\n",
    "&\\text{Model }H_1:\\qquad \\text{Temp}_i = \\alpha+\\gamma(t_i-2000)+\\lambda\\text{Temp}_{i-1}+N(0,\\sigma^2)\n",
    "\\end{align*}\n",
    "Fit the two models, and perform a hypothesis test of whether $H_0$ is adequate.\n",
    "```\n",
    "def fit_climateX(temp, t):\n",
    "    # Input: temp and t are numpy vectors\n",
    "    # TODO: find maximum likelihood estimates\n",
    "    return (α,γ,σ) for H0, return (α,γ,λ,σ) for H1\n",
    "\n",
    "def test_climate0(temp, t):\n",
    "    # TODO: test, using parametric resampling, and λhat as the test statistic\n",
    "    # About 20,000 samples should be sufficient to pass the tester\n",
    "    return pvalue\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**graphrw_stationary.** Consider a random walk on the vertices of an undirected graph, as follows: each timestep we take one of the edges chosen at random, each edge from our current vertex equally likely. Find the stationary distribution.\n",
    "\n",
    "<img src=\"res/graphrw.svg\" style=\"height:6em\">\n",
    "\n",
    "```\n",
    "def graphrw_stationary(adj):\n",
    "    # Input: adj is a numpy matrix, specifying the adjacency matrix\n",
    "    # TODO: Find the stationary distribution π, as a numpy vector\n",
    "    return π\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**hmm_predict.** Consider a moving object with noisy location readings. Let $X_n$ be the location at timestep $n\\geq0$, $X_n\\in\\{0,1,\\dots,\\texttt{MAX\\_STATE}\\}$, and $Y_n$ the reading. The exact simulator for this system can be found on the [example sheet](https://www.cl.cam.ac.uk/teaching/current/DataSci/ex/ex4.pdf). We wish to find the distribution of $X_n$ given $y_0,\\dots,y_n$. The \n",
    "distribution of $X_0$ is also given, as $\\texttt{pr0}=[\\operatorname{Pr}_{X_0}(0),\\dots,\\operatorname{Pr}_{X_0}(\\texttt{MAX\\_STATE})]$.\n",
    "\n",
    "<img src=\"res/hmm.svg\" style=\"height:11em\">\n",
    "\n",
    "```\n",
    "def hmm_predict(pr0, y):\n",
    "    # Input: pr0, a numpy vector with the distribution of X0\n",
    "    #        y, a numpy vector with the sequence of noisy readings\n",
    "    #        (Note than MAX_STATE = len(pr0) - 1.)\n",
    "    # TODO: find the distribution of (Xn | y0,...,yn)\n",
    "    return this dist. as a numpy vector\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TEST\n",
    "_The Moodle checker will look for a markdown cell with the contents `# TEST`, and ignore everything beneath it. Put your working code above this cell, and put any experiments and tests below._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([10.64,  9.43,  9.19, 10.03, 11.27, 10.71,  9.54, 10.45,  8.36,\n",
    "    7.08, 10.23, 10.19, 10.12,  8.72, 10.12,  8.19,  9.45, 11.32,\n",
    "    10.89, 10.76])\n",
    "fit_mrrw(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'https://www.cl.cam.ac.uk/teaching/current/DataSci/data/climate_202610.csv'\n",
    "climate = pandas.read_csv(url)\n",
    "cambridge11 = climate.loc[(climate.station=='Cambridge') & (climate.mm==11)].sort_values('yyyy')\n",
    "\n",
    "print(fit_climate0(cambridge11.temp.values, cambridge11.yyyy.values))\n",
    "print(fit_climate1(cambridge11.temp.values, cambridge11.yyyy.values))\n",
    "print(test_climate0(cambridge11.temp.values, cambridge11.yyyy.values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edges = [(0,1), (1,2), (1,3), (2,3)]\n",
    "adj = np.zeros((4,4))\n",
    "for i,j in edges:\n",
    "    adj[i,j] = 1\n",
    "    adj[j,i] = 1\n",
    "graphrw_stationary(adj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pr0 = np.full(10, 1/10)\n",
    "y = [3,3,5,4,4,5,3,3,4,3,5,4]\n",
    "prx = [hmm_predict(pr0, y[:i]) for i in range(1, len(y))]\n",
    "\n",
    "fig,ax = plt.subplots(figsize=(4,3))\n",
    "ax.scatter(range(len(y)), y)\n",
    "im = ax.imshow(np.array(prx).transpose(), cmap='binary')\n",
    "im.set_clim(0,2)\n",
    "ax.invert_yaxis()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
