L13 - Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real f(x): x*1.5 + -0.5 + e\n",
      "Estimated f(x): x*1.4 + -0.5 + e\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.linspace(0, 1, 50)\n",
    "def f(v):\n",
    "    return (v*1.5 - .5) + np.random.normal(0, .2, size=v.shape)\n",
    "Y = f(X)\n",
    "\n",
    "fig = plt.figure(figsize=(10, 3))\n",
    "ax = fig.subplots(1, 2)\n",
    "\n",
    "ax[0].scatter(X, Y, label=\"data\")\n",
    "ax[0].set_ylabel(\"Some unit\")\n",
    "ax[0].set_xlabel(\"Some other unit\")\n",
    "ax[0].legend()\n",
    "\n",
    "from scipy.stats import linregress\n",
    "slope, intercept, r_value, p_value, std_err = linregress(X, Y)\n",
    "\n",
    "ax[1].scatter(X, Y, label=\"data\")\n",
    "ax[1].plot(X, X*slope + intercept, c='red', label=\"trend line\")\n",
    "ax[1].set_ylabel(\"Some unit\")\n",
    "ax[1].set_xlabel(\"Some other unit\")\n",
    "ax[1].legend()\n",
    "\n",
    "\n",
    "print(\"Real f(x): x*%.1f + %.1f + e\" % (1.5, -.5))\n",
    "print(\"Estimated f(x): x*%.1f + %.1f + e\" % (slope, intercept))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_samples = 30\n",
    "n_variables = 2\n",
    "X = np.zeros((n_samples, n_variables))\n",
    "X[:, 0] = np.random.randint(0, 2, size=n_samples)\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": [
      "fps: 19.8\n"
     ]
    }
   ],
   "source": [
    "n_samples = 100\n",
    "n_outcomes = 2\n",
    "\n",
    "import time\n",
    "\n",
    "fps = 20\n",
    "fig, ax = plt.subplots()\n",
    "ax.set_ylim((0, 1))\n",
    "title = plt.xlabel(\"n=%i\" % 0)\n",
    "if n_outcomes == 2:\n",
    "    labels = ['Heads', 'Tails']\n",
    "else:\n",
    "    labels = [\"Side %i\" % (i+1) for i in range(n_outcomes)]\n",
    "h = ax.bar(labels, np.zeros(n_outcomes), align='center')#, color=plt.get_cmap('Pastel1'))\n",
    "\n",
    "outcomes = np.zeros(n_outcomes)\n",
    "\n",
    "plt.show(block=False)\n",
    "\n",
    "T = time.time()\n",
    "for n in range(n_samples):\n",
    "    t = time.time()\n",
    "    outcomes[np.random.randint(n_outcomes)] += 1\n",
    "\n",
    "    title.set_text(\"n=%i\" % (n+1))\n",
    "    for i in range(n_outcomes):\n",
    "        h[i].set_height(outcomes[i]/np.sum(outcomes))\n",
    "\n",
    "    fig.canvas.draw()\n",
    "    fig.canvas.flush_events()\n",
    "    time.sleep(max(0, t+1/fps-time.time()))\n",
    "\n",
    "print(\"fps: %.1f\" % (n_samples/(time.time()-T)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import time\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def live_update_demo(blit = False):\n",
    "    x = np.linspace(0,50., num=100)\n",
    "    X,Y = np.meshgrid(x,x)\n",
    "    fig = plt.figure()\n",
    "    ax1 = fig.add_subplot(2, 1, 1)\n",
    "    ax2 = fig.add_subplot(2, 1, 2)\n",
    "\n",
    "    fig.canvas.draw()   # note that the first draw comes before setting data \n",
    "\n",
    "    h1 = ax1.imshow(X, vmin=-1, vmax=1, interpolation=\"None\", cmap=\"RdBu\")\n",
    "\n",
    "    h2, = ax2.plot(x, lw=3)\n",
    "    text = ax2.text(0.8,1.5, \"\")\n",
    "    ax2.set_ylim([-1,1])\n",
    "\n",
    "\n",
    "    if blit:\n",
    "        # cache the background\n",
    "        axbackground = fig.canvas.copy_from_bbox(ax1.bbox)\n",
    "        ax2background = fig.canvas.copy_from_bbox(ax2.bbox)\n",
    "\n",
    "    t_start = time.time()\n",
    "    k=0.\n",
    "    for i in np.arange(1000):\n",
    "        h1.set_data(np.sin(X/3.+k)*np.cos(Y/3.+k))\n",
    "        h2.set_ydata(np.sin(x/3.+k))\n",
    "        tx = 'Mean Frame Rate:\\n {fps:.3f}FPS'.format(fps= ((i+1) / (time.time() - t_start)) ) \n",
    "        text.set_text(tx)\n",
    "        #print tx\n",
    "        k+=0.11\n",
    "        if blit:\n",
    "            # restore background\n",
    "            fig.canvas.restore_region(axbackground)\n",
    "            fig.canvas.restore_region(ax2background)\n",
    "\n",
    "            # redraw just the points\n",
    "            ax1.draw_artist(h1)\n",
    "            ax2.draw_artist(h2)\n",
    "\n",
    "            # fill in the axes rectangle\n",
    "            fig.canvas.blit(ax1.bbox)\n",
    "            fig.canvas.blit(ax2.bbox)\n",
    "            # in this post http://bastibe.de/2013-05-30-speeding-up-matplotlib.html\n",
    "            # it is mentionned that blit causes strong memory leakage. \n",
    "            # however, I did not observe that.\n",
    "\n",
    "        else:\n",
    "            # redraw everything\n",
    "            fig.canvas.draw()\n",
    "            fig.canvas.flush_events()\n",
    "\n",
    "\n",
    "        plt.pause(0.000000000001) \n",
    "        #plt.pause calls canvas.draw(), as can be read here:\n",
    "        #http://bastibe.de/2013-05-30-speeding-up-matplotlib.html\n",
    "        #however with Qt4 (and TkAgg??) this is needed. It seems,using a different backend, \n",
    "        #one can avoid plt.pause() and gain even more speed.\n",
    "\n",
    "\n",
    "#live_update_demo(True) # 28 fps\n",
    "live_update_demo(False) # 18 fps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "line, = ax.plot(np.random.randn(100))\n",
    "\n",
    "tstart = time.time()\n",
    "num_plots = 0\n",
    "while time.time()-tstart < 1:\n",
    "    line.set_ydata(np.random.randn(100))\n",
    "    fig.canvas.draw()\n",
    "    fig.canvas.flush_events()\n",
    "    num_plots += 1\n",
    "print(num_plots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nbAgg'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib\n",
    "matplotlib.get_backend()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}