5_scipy_pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Scientific analysis in Python"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![scipy.png](media/scipy.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    " - collection of packages and functions based on NumPy\n",
    " - the goal is to have similar functionality as is available in MATLAB, IDL, R...\n",
    " - heavily integrated with NumPy and matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Organized in Sub-packages\n",
    "### need to be individually imported\n",
    "\n",
    "    cluster \t    Clustering algorithms\n",
    "    constants       Physical and mathematical constants\n",
    "    fftpack         Fast Fourier Transform routines\n",
    "    integrate       Integration and ordinary differential equation solvers\n",
    "    interpolate     Interpolation and smoothing splines\n",
    "    io              Input and Output\n",
    "    linalg          Linear algebra\n",
    "    ndimage         N-dimensional image processing\n",
    "    odr             Orthogonal distance regression\n",
    "    optimize        Optimization and root-finding routines\n",
    "    signal          Signal processing\n",
    "    sparse          Sparse matrices and associated routines\n",
    "    spatial         Spatial data structures and algorithms\n",
    "    special         Special functions\n",
    "    stats           Statistical distributions and functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "DO:\n",
    "\n",
    "from scipy import ndimage\n",
    "\n",
    "DON'T:\n",
    "\n",
    "import scipy\n",
    "\n",
    "from scipy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Interpolation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1d Interpolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import interp1d\n",
    "\n",
    "x = np.linspace(0, 10, num=11, endpoint=True)\n",
    "y = np.cos(-x**2/9.0)\n",
    "f = interp1d(x, y)\n",
    "f2 = interp1d(x, y, kind='cubic')\n",
    "f3 = interp1d(x, y, kind='next')\n",
    "\n",
    "xnew = np.linspace(0, 10, num=100, endpoint=True)\n",
    "plt.plot(x, y, 'o')\n",
    "plt.plot(xnew, f(xnew), '-') \n",
    "plt.plot(xnew, f2(xnew), '--')\n",
    "plt.plot(xnew, f3(xnew), ':')\n",
    "plt.legend(['data', 'linear', 'cubic','nearest'], loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 2d Interpolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import griddata\n",
    "\n",
    "def func(x, y):\n",
    "    return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2\n",
    "\n",
    "grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]\n",
    "\n",
    "points = np.random.rand(1000, 2)\n",
    "values = func(points[:,0], points[:,1])\n",
    "\n",
    "grid_z0 = griddata(points, values, (grid_x, grid_y), method='nearest')\n",
    "grid_z1 = griddata(points, values, (grid_x, grid_y), method='linear')\n",
    "grid_z2 = griddata(points, values, (grid_x, grid_y), method='cubic')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "plt.subplot(221)\n",
    "plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin='lower')\n",
    "plt.plot(points[:,0], points[:,1], 'k.', ms=1)\n",
    "plt.title('Original')\n",
    "plt.subplot(222)\n",
    "plt.imshow(grid_z0.T, extent=(0,1,0,1), origin='lower')\n",
    "plt.title('Nearest')\n",
    "plt.subplot(223)\n",
    "plt.imshow(grid_z1.T, extent=(0,1,0,1), origin='lower')\n",
    "plt.title('Linear')\n",
    "plt.subplot(224)\n",
    "plt.imshow(grid_z2.T, extent=(0,1,0,1), origin='lower')\n",
    "plt.title('Cubic')\n",
    "plt.gcf().set_size_inches(6, 6)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Integration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Numerical Integration\n",
    "\n",
    "Suppose we want to integrate any function $f(x)$ within the boarders $a$ and $b$\n",
    "\n",
    "$\\int_{a}^{b} f(x) dx$\n",
    "\n",
    "Say for a concrete example $\\int_{0}^{\\pi/2} sin(x) dx$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.integrate import quad\n",
    "\n",
    "# quad integrates the function using adaptive Gaussian quadrature from the Fortran QUADPACK library\n",
    "\n",
    "res, err = quad(np.sin, 0, np.pi/2)\n",
    "\n",
    "print(res)\n",
    "print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Integrating ordinary differential equations (ODE)\n",
    "\n",
    "Lets use the example: $\\frac{dy}{dt} = -2y$\n",
    "\n",
    "We want to integrate this equation between $t=0$ and $t=4$ with initial condition $y(t=0)=1$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.integrate import odeint\n",
    "\n",
    "def calc_derivative(ypos, time):\n",
    "    return -2 * ypos\n",
    "\n",
    "time_vec = np.linspace(0, 4, 40)\n",
    "y = odeint(calc_derivative, y0=1, t=time_vec)\n",
    "\n",
    "plt.plot(time_vec,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Curve fitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import optimize\n",
    "\n",
    "x_data = np.linspace(-5, 5, num=50)\n",
    "y_data = 2.9 * np.sin(1.5 * x_data) + np.random.normal(size=50)\n",
    "\n",
    "# We know that the data lies on a sine wave, but not the amplitudes or the period.\n",
    "\n",
    "plt.plot(x_data,y_data,\"o\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Set up a function with free parameters to fit to the data\n",
    "\n",
    "def test_func(x, a, b):\n",
    "    return a * np.sin(b * x)\n",
    "\n",
    "params, params_covariance = optimize.curve_fit(test_func, x_data, y_data, p0=[2, 2])\n",
    "print(params)\n",
    "\n",
    "plt.plot(x_data,y_data,\"o\")\n",
    "plt.plot(x_data,test_func(x_data,params[0],params[1]),\"r-\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Finding the minimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import optimize\n",
    "\n",
    "def f(x):\n",
    "    return x**2 + 10*np.sin(x)\n",
    "\n",
    "x = np.arange(-10, 10, 0.1)\n",
    "plt.plot(x, f(x)) \n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "result = optimize.minimize(f, x0=0)\n",
    "\n",
    "# Uses by default the Broyden–Fletcher–Goldfarb–Shanno algorithm but another algorithm can be defined.\n",
    "# result is a compound object that contains all the information of the minimization attempt\n",
    "\n",
    "print(result)\n",
    "plt.plot(x, f(x))\n",
    "plt.plot(result.x, f(result.x),\"ro\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Orbit fitting with SciPy\n",
    "![lsmc.jpg](media/lsmc.jpg)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![lsmc2.jpg](media/lsmc2.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Fourier Transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy import fftpack\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "time_step = 0.02\n",
    "period = 5.\n",
    "\n",
    "time_vec = np.arange(0, 20, time_step)\n",
    "sig = (np.sin(2 * np.pi / period * time_vec) + 0.5 * np.random.randn(time_vec.size))\n",
    "\n",
    "plt.plot(time_vec, sig, label='Original signal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# The FFT of the signal\n",
    "sig_fft = fftpack.fft(sig)\n",
    "\n",
    "# And the power (sig_fft is of complex dtype)\n",
    "power = np.abs(sig_fft)\n",
    "\n",
    "# The corresponding frequencies\n",
    "sample_freq = fftpack.fftfreq(sig.size, d=time_step)\n",
    "\n",
    "# Plot the FFT power\n",
    "plt.figure(figsize=(6, 5))\n",
    "plt.plot(sample_freq, power)\n",
    "plt.xlabel('Frequency [Hz]')\n",
    "plt.ylabel('power')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Find the peak frequency: we can focus on only the positive frequencies\n",
    "pos_mask = np.where(sample_freq > 0)\n",
    "freqs = sample_freq[pos_mask]\n",
    "peak_freq = freqs[power[pos_mask].argmax()]\n",
    "\n",
    "high_freq_fft = sig_fft.copy()\n",
    "high_freq_fft[np.abs(sample_freq) > peak_freq] = 0\n",
    "filtered_sig = fftpack.ifft(high_freq_fft)\n",
    "\n",
    "plt.figure(figsize=(6, 5))\n",
    "plt.plot(time_vec, sig, label='Original signal')\n",
    "plt.plot(time_vec, filtered_sig, linewidth=3, label='Filtered signal')\n",
    "plt.xlabel('Time [s]')\n",
    "plt.ylabel('Amplitude')\n",
    "\n",
    "plt.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Image processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import astropy.io.fits as fits\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import ndimage as nd\n",
    "from scipy.ndimage.filters import gaussian_filter\n",
    "\n",
    "fits_file = fits.open(\"./data/exohost.fits\")\n",
    "data_array = fits_file[0].data\n",
    "\n",
    "plt.imshow(data_array, origin='lower', cmap=plt.cm.gist_heat , vmin=-10, vmax=200)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### High-pass filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "low_frequ = gaussian_filter(data_array, sigma=10, truncate=6.1)\n",
    "\n",
    "high_pass_filtered_image = data_array - low_frequ\n",
    "\n",
    "plt.imshow(high_pass_filtered_image, origin='lower', cmap=plt.cm.gist_heat , vmin=-10, vmax=200)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Remove radial average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rot_angles = np.arange(0,180,5)\n",
    "rotated_images = []\n",
    "\n",
    "for angle in rot_angles:\n",
    "    rotated = nd.rotate(data_array, angle, axes=(-1, -2), reshape=False, output=None, order=3, mode='constant', cval=0.0, prefilter=True)\n",
    "    diff = data_array - rotated\n",
    "    rotated_images.append(diff)\n",
    "\n",
    "rotated_images = np.array(rotated_images)\n",
    "final_subtracted_result = np.median(rotated_images, axis=0)\n",
    "\n",
    "plt.imshow(final_subtracted_result, origin='lower', cmap=plt.cm.gist_heat , vmin=-10, vmax=200)\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![pandas1.png](media/pandas_logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- flexible and expressive data structures with NumPy and SciPy under the hood (so fast!)\n",
    "- deals well with heterogeneous data sets and in particular labeled data\n",
    "- well suited for large data sets including missing data\n",
    "- very strong for ordered or un-ordered time series\n",
    "- easy in- and output interfaces with multiple data formats, including excel tables\n",
    "\n",
    "### Think excel for python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating and manipulating pandas data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',\n",
      "               '2013-01-05', '2013-01-06'],\n",
      "              dtype='datetime64[ns]', freq='D')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# We want to record different measurements taken at different dates\n",
    "\n",
    "dates = pd.date_range('20130101', periods=6)\n",
    "\n",
    "print(dates)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   A         B         C         D\n",
      "2013-01-01  1.038457  1.863826  0.284136 -0.685346\n",
      "2013-01-02  0.092786 -0.806629 -0.540774 -0.741719\n",
      "2013-01-03 -1.513971  2.061782  0.305276  3.137007\n",
      "2013-01-04  0.554381  2.039018  0.438309  0.003846\n",
      "2013-01-05 -0.550535 -1.313742 -1.715077  1.426692\n",
      "2013-01-06  0.317437  1.638710  0.387025  1.033824\n"
     ]
    }
   ],
   "source": [
    "# Lets now create a data frame object that has several columns and is indexed by the dates we created \n",
    "\n",
    "df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))\n",
    "\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     A          B    C  D      E    F\n",
      "0  1.0 2013-01-02  1.0  3   test  foo\n",
      "1  1.0 2013-01-02  1.0  3  train  foo\n",
      "2  1.0 2013-01-02  1.0  3   test  foo\n",
      "3  1.0 2013-01-02  1.0  3  train  foo\n"
     ]
    }
   ],
   "source": [
    "# data frames can have completely different data types in each column\n",
    "\n",
    "df2 = pd.DataFrame({ 'A' : 1.,\n",
    "                     'B' : pd.Timestamp('20130102'),\n",
    "                     'C' : pd.Series(1,index=list(range(4)),dtype='float32'),\n",
    "                     'D' : np.array([3] * 4,dtype='int32'),\n",
    "                     'E' : pd.Categorical([\"test\",\"train\",\"test\",\"train\"]),\n",
    "                     'F' : 'foo' })\n",
    "\n",
    "print(df2)\n",
    "#print(df2.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1.0\n",
      "1    1.0\n",
      "2    1.0\n",
      "3    1.0\n",
      "Name: A, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# You can select columns by labels\n",
    "\n",
    "print(df2[\"A\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A    1.0\n",
      "C    1.0\n",
      "D    3.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# We can perform statistical operations\n",
    "\n",
    "print(df2.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   A         B         C         D\n",
      "2013-01-01  1.038457  1.863826  0.284136 -0.685346\n",
      "2013-01-02  0.092786 -0.806629 -0.540774 -0.741719\n",
      "2013-01-03 -1.513971  2.061782  0.305276  3.137007\n",
      "2013-01-04  0.554381  2.039018  0.438309  0.003846\n",
      "2013-01-05 -0.550535 -1.313742 -1.715077  1.426692\n",
      "2013-01-06  0.317437  1.638710  0.387025  1.033824\n",
      "                   A         B         C         D\n",
      "2013-01-01  1.038457  1.863826  0.284136 -0.685346\n",
      "2013-01-02  1.131243  1.057197 -0.256638 -1.427065\n",
      "2013-01-03 -0.382729  3.118979  0.048638  1.709942\n",
      "2013-01-04  0.171652  5.157998  0.486947  1.713787\n",
      "2013-01-05 -0.378883  3.844255 -1.228130  3.140479\n",
      "2013-01-06 -0.061446  5.482965 -0.841105  4.174303\n"
     ]
    }
   ],
   "source": [
    "# We can apply numpy functions\n",
    "\n",
    "print(df)\n",
    "print(df.apply(np.cumsum))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can easily plot data\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "df.plot()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}