SlidingWindow2-PersistentHomology.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Persistent Homology of Sliding Windows\n",
    "\n",
    "Now that we have heuristically explored the geometry of sliding window embeddings of 1D signals, we will apply tools from persistent homology to quantify the geometry.  As before, we first need to import all necessary libraries and setup code to compute sliding window embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do all of the imports and setup inline plotting\n",
    "import numpy as np\n",
    "\n",
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import gridspec\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "from scipy.interpolate import InterpolatedUnivariateSpline\n",
    "\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "from IPython.display import clear_output\n",
    "\n",
    "from ripser import ripser\n",
    "from persim import plot_diagrams\n",
    "\n",
    "def getSlidingWindow(x, dim, Tau, dT):\n",
    "    \"\"\"\n",
    "    Return a sliding window of a time series,\n",
    "    using arbitrary sampling.  Use linear interpolation\n",
    "    to fill in values in windows not on the original grid\n",
    "    Parameters\n",
    "    ----------\n",
    "    x: ndarray(N)\n",
    "        The original time series\n",
    "    dim: int\n",
    "        Dimension of sliding window (number of lags+1)\n",
    "    Tau: float\n",
    "        Length between lags, in units of time series\n",
    "    dT: float\n",
    "        Length between windows, in units of time series\n",
    "    Returns\n",
    "    -------\n",
    "    X: ndarray(N, dim)\n",
    "        All sliding windows stacked up\n",
    "    \"\"\"\n",
    "    N = len(x)\n",
    "    NWindows = int(np.floor((N-dim*Tau)/dT))\n",
    "    if NWindows <= 0:\n",
    "        print(\"Error: Tau too large for signal extent\")\n",
    "        return np.zeros((3, dim))\n",
    "    X = np.zeros((NWindows, dim))\n",
    "    spl = InterpolatedUnivariateSpline(np.arange(N), x)\n",
    "    for i in range(NWindows):\n",
    "        idxx = dT*i + Tau*np.arange(dim)\n",
    "        start = int(np.floor(idxx[0]))\n",
    "        end = int(np.ceil(idxx[-1]))+2\n",
    "        # Only take windows that are within range\n",
    "        if end >= len(x):\n",
    "            X = X[0:i, :]\n",
    "            break\n",
    "        X[i, :] = spl(idxx)\n",
    "    return X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Single Sine: Maximum Persistence vs Window Size\n",
    "\n",
    "First, let's examine the 1D persistent homology of the sliding window embedding of a single perfect sinusoid.  Choose dim and $\\tau$ to change the extent (window size) to different values, and examine how the maximum persistence changes.  How does this support what you saw in the first module?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def on_value_change(change):\n",
    "    execute_computation1()\n",
    "    \n",
    "dimslider = widgets.IntSlider(min=1,max=100,value=20,description='Dimension:',continuous_update=False)\n",
    "dimslider.observe(on_value_change, names='value')\n",
    "\n",
    "Tauslider = widgets.FloatSlider(min=0.1,max=5,step=0.1,value=1,description=r'\\(\\tau :\\)' ,continuous_update=False)\n",
    "Tauslider.observe(on_value_change, names='value')\n",
    "\n",
    "noiseampslider = widgets.FloatSlider(min=0,max=2,step=0.1,value=0,description='Noise Amplitude',continuous_update=False)\n",
    "noiseampslider.observe(on_value_change, names='value')\n",
    "\n",
    "display(widgets.HBox(( dimslider,Tauslider, noiseampslider)))\n",
    "\n",
    "noise = np.random.randn(10000)\n",
    "\n",
    "fig = plt.figure(figsize=(9.5, 4))\n",
    "\n",
    "def execute_computation1():\n",
    "    plt.clf()\n",
    "    # Step 1: Setup the signal\n",
    "    T = 40 # The period in number of samples\n",
    "    NPeriods = 4 # How many periods to go through\n",
    "    N = T*NPeriods # The total number of samples\n",
    "    t = np.linspace(0, 2*np.pi*NPeriods, N+1)[0:N] # Sampling indices in time\n",
    "    x = np.cos(t) # The final signal\n",
    "    x += noiseampslider.value * noise[:len(x)]\n",
    "    \n",
    "    # Step 2: Do a sliding window embedding\n",
    "    dim = dimslider.value\n",
    "    Tau = Tauslider.value\n",
    "    dT = 0.5\n",
    "    X = getSlidingWindow(x, dim, Tau, dT)\n",
    "    extent = Tau*dim\n",
    "\n",
    "    # Step 3: Do Rips Filtration\n",
    "    PDs = ripser(X, maxdim=1)['dgms']\n",
    "    I = PDs[1]\n",
    "\n",
    "    # Step 4: Perform PCA down to 2D for visualization\n",
    "    pca = PCA(n_components = 2)\n",
    "    Y = pca.fit_transform(X)\n",
    "    eigs = pca.explained_variance_\n",
    "    \n",
    "    # Step 5: Plot original signal, 2-D projection, and the persistence diagram\n",
    "    gs = gridspec.GridSpec(2, 2)\n",
    "    ax = plt.subplot(gs[0,0])\n",
    "    ax.plot(x)\n",
    "    ax.set_ylim((2*min(x), 2*max(x)))\n",
    "    ax.set_title(\"Original Signal\")\n",
    "    ax.set_xlabel(\"Sample Number\")\n",
    "    yr = np.max(x)-np.min(x)\n",
    "    yr = [np.min(x)-0.1*yr, np.max(x)+0.1*yr]\n",
    "    ax.plot([extent, extent], yr, 'r')\n",
    "    ax.plot([0, 0], yr, 'r')     \n",
    "    ax.plot([0, extent], [yr[0]]*2, 'r')\n",
    "    ax.plot([0, extent], [yr[1]]*2, 'r')\n",
    "\n",
    "    ax2 = plt.subplot(gs[1,0])\n",
    "    plot_diagrams(PDs)\n",
    "    plt.title(\"Max Persistence = %.3g\"%np.max(I[:, 1] - I[:, 0]))\n",
    "    \n",
    "    ax3 = plt.subplot(gs[:,1])\n",
    "    ax3.scatter(Y[:, 0], Y[:, 1])\n",
    "    plt.axis('equal')\n",
    "    plt.title(\"2-D PCA, Eigenvalues: %.3g, %.3g \"%(eigs[0],eigs[1]))\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    \n",
    "execute_computation1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions\n",
    "1. Examining the effect of window extent on maximal persistence (with no noise):\n",
    "  1. Describe the effect of dimension and $\\tau$ on maximal persistence. What does increasing one of these factors while keeping the other constant to do the window extent? What does it do to the maximal persistence? Explain your observations.\n",
    "  1. Is the maximal persistence a function of the window extent? Justify your answer and explain it geometrically (you may want to refer to the PCA projection plots).\n",
    "  1. Describe the relation between the eigenvalues and the maximal persistence. (Hint: How do the eigenvalues affect roundness? How does roundness affect persistence?)\n",
    "  1. Write code to plot scatter plots of maximal persistence vs dimension for fixed $\\tau$ and vs $\\tau$ for fixed dimension, and maximal persistence vs. dimension for fixed extent (say, extent = 40). Comment on your results.\n",
    "<br><br>\n",
    "1. Now add some noise to your plots. Notice that the maximal persistence point on the persistence diagram is colored in red.\n",
    "  1. What do you observe regarding the persistence diagram? Explain your observations in terms of your understading of persistence.\n",
    "  1. At what noise amplitude does the point with maximal persistence appear to get 'swallowed up' by the noise in the diagram? How does this correspond with the 2-D projection?\n",
    "  1. Note that the original signal has amplitude 1. As you increase noise, is it clear by looking at the signal that there is a periodic function underlying it? How does persistence allow detection of periodicity? Explain.\n",
    "  1. For fixed noise amplitude (say 1), increase dimension. What effect does this have on detection of periodicity using your method?\n",
    "  1. Does varying $\\tau$ for the same fixed amplitude have the same effect? Explain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two Sines\n",
    "\n",
    "Now let's examine the persistent homology of a signal consisting of the sum of two sinusoids.  First, setup and examine the signal.  We will use a slightly coarser sampling rate than we did in the first module to keep the persistent homology code running quickly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 1: Setup the signal\n",
    "T1 = 10 # The period of the first sine in number of samples\n",
    "T2 = T1*3 # The period of the second sine in number of samples\n",
    "NPeriods = 10 # How many periods to go through, relative to the second sinusoid\n",
    "N = T2*NPeriods # The total number of samples\n",
    "t = np.arange(N) # Time indices\n",
    "x = np.cos(2*np.pi*(1.0/T1)*t) # The first sinusoid\n",
    "x += np.cos(2*np.pi*(1.0/T2)*t) # The second sinusoid\n",
    "plt.figure();\n",
    "plt.plot(x);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Persistent Homology\n",
    "\n",
    "Now, we will compute the persistent homology of the above signal following a sliding window embedding.  Run this code. Then examine the outputs with both harmonic sinusoids and noncommensurate sinusoids, and note the difference in the persistence diagrams. Note that the two points with highest persistence are highlighted in red on the diagram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def on_value_change(change):\n",
    "    execute_computation3()\n",
    "\n",
    "secondfreq = widgets.Dropdown(options=[ 2, 3, np.pi],value=3,description='Second Frequency:',disabled=False)\n",
    "secondfreq.observe(on_value_change,names='value')\n",
    "\n",
    "noiseampslider = widgets.FloatSlider(min=0,max=2,step=0.1,value=0,description='Noise Amplitude',continuous_update=False)\n",
    "noiseampslider.observe(on_value_change, names='value')\n",
    "\n",
    "dimslider = widgets.IntSlider(min=1,max=100,value=20,description='Dimension:',continuous_update=False)\n",
    "dimslider.observe(on_value_change, names='value')\n",
    "\n",
    "Tauslider = widgets.FloatSlider(min=0.1,max=5,step=0.1,value=1,description=r'\\(\\tau :\\)' ,continuous_update=False)\n",
    "Tauslider.observe(on_value_change, names='value')\n",
    "\n",
    "display(widgets.HBox(( dimslider,Tauslider)))\n",
    "display(widgets.HBox(( secondfreq,noiseampslider)))\n",
    "\n",
    "noise = np.random.randn(10000)\n",
    "\n",
    "fig = plt.figure(figsize=(9.5, 5))\n",
    "\n",
    "def execute_computation3():\n",
    "    # Step 1: Setup the signal\n",
    "    T1 = 10 # The period of the first sine in number of samples\n",
    "    T2 = T1*secondfreq.value # The period of the second sine in number of samples\n",
    "    NPeriods = 5 # How many periods to go through, relative to the second sinusoid\n",
    "    N = T2*NPeriods # The total number of samples\n",
    "    t = np.arange(N) # Time indices\n",
    "    x = np.cos(2*np.pi*(1.0/T1)*t) # The first sinusoid\n",
    "    x += np.cos(2*np.pi*(1.0/T2)*t) # The second sinusoid\n",
    "    x += noiseampslider.value * noise[:len(x)]\n",
    "\n",
    "    #Step 2: Do a sliding window embedding\n",
    "    dim = dimslider.value\n",
    "    Tau = Tauslider.value\n",
    "    dT = 0.35\n",
    "    X = getSlidingWindow(x, dim, Tau, dT)\n",
    "    extent = Tau*dim\n",
    "\n",
    "    #Step 3: Do Rips Filtration\n",
    "    PDs = ripser(X, maxdim=1)['dgms']\n",
    "\n",
    "    #Step 4: Perform PCA down to 2D for visualization\n",
    "    pca = PCA()\n",
    "    Y = pca.fit_transform(X)\n",
    "    eigs = pca.explained_variance_\n",
    "\n",
    "    #Step 5: Plot original signal and the persistence diagram\n",
    "    gs = gridspec.GridSpec(3, 2,width_ratios=[1, 2],height_ratios=[2,2,1])\n",
    "    \n",
    "    ax = plt.subplot(gs[0,1])\n",
    "    ax.plot(x)\n",
    "    ax.set_ylim((1.25*min(x), 1.25*max(x)))\n",
    "    ax.set_title(\"Original Signal\")\n",
    "    ax.set_xlabel(\"Sample Number\")\n",
    "    yr = np.max(x)-np.min(x)\n",
    "    yr = [np.min(x)-0.1*yr, np.max(x)+0.1*yr]\n",
    "    ax.plot([extent, extent], yr, 'r')\n",
    "    ax.plot([0, 0], yr, 'r')     \n",
    "    ax.plot([0, extent], [yr[0]]*2, 'r')\n",
    "    ax.plot([0, extent], [yr[1]]*2, 'r')\n",
    "\n",
    "    ax2 = plt.subplot(gs[0:2,0])\n",
    "    plot_diagrams(PDs)\n",
    "    maxind = np.argpartition(PDs[1][:,1]-PDs[1][:,0], -2)[-2:]\n",
    "    max1 = PDs[1][maxind[1],1] -  PDs[1][maxind[1],0]\n",
    "    max2 = PDs[1][maxind[0],1] -  PDs[1][maxind[0],0]\n",
    "    ax2.set_title(\"Persistence Diagram\\n Max Pers: %.3g 2nd Pers: %.3g\"%(max1,max2) )\n",
    "\n",
    "    ax3 = plt.subplot(gs[2,0])\n",
    "    eigs = eigs[0:min(len(eigs), 10)]\n",
    "    ax3.bar(np.arange(len(eigs)), eigs)\n",
    "    ax3.set_xlabel(\"Eigenvalue Number\")\n",
    "    ax3.set_ylabel(\"Eigenvalue\")\n",
    "    ax3.set_title(\"PCA Eigenvalues\")\n",
    "\n",
    "    c = plt.get_cmap('jet')\n",
    "    C = c(np.array(np.round(np.linspace(0, 255, Y.shape[0])), dtype=np.int32))\n",
    "    C = C[:, 0:3]\n",
    "    ax4 = fig.add_subplot(gs[1:,1], projection = '3d')\n",
    "    ax4.set_title(\"PCA of Sliding Window Embedding\")\n",
    "    ax4.scatter(Y[:, 0], Y[:, 1], Y[:, 2], c=C)\n",
    "    ax4.set_aspect('equal', 'datalim')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "\n",
    "execute_computation3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Questions\n",
    "\n",
    "1. Describe a key difference in the persistence diagrams between the harmonic and non-commensurate cases. Explain this difference in terms of the 3-D projection of the PCA embedding. (Hint: consider the shape and the intrinsic dimension of the projection.)\n",
    "<br><br>\n",
    "1. Explain how the persistence diagram allows the detection of non-commensurate sinusoids.\n",
    "<br><br>\n",
    "1. Can the persistence diagram distinguish between a single sinusoid and the sum of two harmonic sinusoids?\n",
    "<br><br>\n",
    "1. Looking back at the 2-D projection of the PCA in the harmonic case from the first lab, explain why the persistence diagram might be surprising if you had only seen that projection. How does looking at the 3-D projection make the persistence diagram less of a surprise?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h1>Field of Coefficients</h1><BR>\n",
    "\n",
    "Now we will examine a surprising geometric property that is able to tell apart two signals which look quite similar.  First, we generate and plot the two signals below:\n",
    "\n",
    "$$g_1 = 0.6\\cos(t) + 0.8\\cos(2t)$$\n",
    "\n",
    "$$g_2 = 0.8\\cos(t) + 0.6\\cos(2t)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Step 1: Setup the signal\n",
    "T1 = 100 # The period of the first sine in number of samples\n",
    "T2 = 50\n",
    "NPeriods = 5 # How many periods to go through, relative to the first sinusoid\n",
    "N = T1*NPeriods # The total number of samples\n",
    "t = np.arange(N) # Time indices\n",
    "coeff1 = 0.6\n",
    "coeff2 = 0.8\n",
    "g1 = coeff1*np.cos(2*np.pi*(1.0/T1)*t) # The first sinusoid\n",
    "g1 += coeff2*np.cos(2*np.pi*(1.0/T2)*t) # The second sinusoid\n",
    "\n",
    "g2 = coeff2*np.cos(2*np.pi*(1.0/T1)*t) # The first sinusoid\n",
    "g2 += coeff1*np.cos(2*np.pi*(1.0/T2)*t) # The second sinusoid\n",
    "\n",
    "fig = plt.figure(figsize=(9.5, 4))\n",
    "plot1, = plt.plot(g1,label=\"g1 = %.2gcos(t) + %.2gcos(2t)\"%(coeff1, coeff2))\n",
    "plot2, = plt.plot(g2,color='r',label=\"g2 = %.2gcos(t) + %.2gcos(2t)\"%(coeff2, coeff1));\n",
    "plt.legend(handles=[plot1,plot2])\n",
    "plt.legend(bbox_to_anchor=(0., 1.02, 0.69, .102), ncol=2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we will look at PCA of the sliding window embeddings of the two signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####g1\n",
    "#Step 2: Do a sliding window embedding\n",
    "dim = 20\n",
    "Tau = 5\n",
    "dT = 2\n",
    "X1 = getSlidingWindow(g1, dim, Tau, dT)\n",
    "\n",
    "#Step 3: Perform PCA down to 2D for visualization\n",
    "pca = PCA()\n",
    "Y = pca.fit_transform(X1)\n",
    "eigs = pca.explained_variance_\n",
    "\n",
    "c = plt.get_cmap('jet')\n",
    "C = c(np.array(np.round(np.linspace(0, 255, Y.shape[0])), dtype=np.int32))\n",
    "C = C[:, 0:3]\n",
    "\n",
    "#Step 4: Plot original signal and PCA of the embedding\n",
    "fig = plt.figure(figsize=(9.5,6))\n",
    "ax = fig.add_subplot(221)\n",
    "ax.plot(g1)\n",
    "ax.set_title(\"Original Signal\")\n",
    "ax.set_xlabel(\"Sample Index\")\n",
    "\n",
    "ax2 = fig.add_subplot(222, projection = '3d')\n",
    "ax2.set_title(\"g1 = %.2gcos(t) + %.2gcos(2t)\"%(coeff1, coeff2))\n",
    "ax2.scatter(Y[:, 0], Y[:, 1], Y[:, 2], c=C)\n",
    "ax2.set_aspect('equal', 'datalim')\n",
    "\n",
    "#####g2\n",
    "X2 = getSlidingWindow(g2, dim, Tau, dT)\n",
    "#Perform PCA down to 2D for visualization\n",
    "pca = PCA()\n",
    "Y = pca.fit_transform(X2)\n",
    "eigs = pca.explained_variance_\n",
    "\n",
    "ax = fig.add_subplot(223)\n",
    "ax.plot(g2)\n",
    "ax.set_title(\"Original Signal\")\n",
    "ax.set_xlabel(\"Sample Index\")\n",
    "\n",
    "ax2 = fig.add_subplot(224, projection = '3d')\n",
    "ax2.set_title(\"g2 = %.2gcos(t) + %.2gcos(2t)\"%(coeff2, coeff1))\n",
    "ax2.scatter(Y[:, 0], Y[:, 1], Y[:, 2], c=C)\n",
    "ax2.set_aspect('equal', 'datalim')\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how one looks more \"twisted\" than the other.  To finish this off, let's compute TDA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Step 1: Do rips filtrations with different field coefficients\n",
    "print(\"Computing persistence diagrams for g1...\")\n",
    "PDs1_2 = ripser(X1, maxdim=1, coeff=2)['dgms'] #Z2 Coefficients\n",
    "PDs1_3 = ripser(X1, maxdim=1, coeff=3)['dgms'] #Z3 Coefficients\n",
    "print(\"Computing persistence diagrams for g2...\")\n",
    "PDs2_2 = ripser(X2, maxdim=1, coeff=2)['dgms']\n",
    "PDs2_3 = ripser(X2, maxdim=1, coeff=3)['dgms']\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(8, 6))\n",
    "\n",
    "plt.subplot(231)\n",
    "plt.plot(g1)\n",
    "\n",
    "plt.subplot(232);\n",
    "plot_diagrams(PDs1_2[1], labels=['H1'])\n",
    "plt.title(\"$g_1$ Persistence Diagram $\\mathbb{Z}/2\\mathbb{Z}$\")\n",
    "\n",
    "plt.subplot(233);\n",
    "plot_diagrams(PDs1_3[1], labels=['H1'])\n",
    "plt.title(\"$g_1$ Persistence Diagram $\\mathbb{Z}/3\\mathbb{Z}$\")\n",
    "\n",
    "plt.subplot(234)\n",
    "plt.plot(g2)\n",
    "\n",
    "plt.subplot(235);\n",
    "plot_diagrams(PDs2_2[1], labels=['H1'])\n",
    "plt.title(\"$g_2$ Persistence Diagram $\\mathbb{Z}/2\\mathbb{Z}$\")\n",
    "\n",
    "plt.subplot(236);\n",
    "plot_diagrams(PDs2_3[1])\n",
    "plt.title(\"$g_2$ Persistence Diagram $\\mathbb{Z}/3\\mathbb{Z}$\")\n",
    "\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen in the corresponding persistence diagrams below, g<SUB>1</SUB>(t) changes when Z mod 3 coefficients are used, while g<SUB>2</SUB>(t) stays the same.  \n",
    "\n",
    "#### Questions\n",
    "1. Why does this change occur for $g_1(t)$ but not $g_2(t)$?  What shape does the sliding window of $g_2(t)$ trace out?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Summary</h1>\n",
    "<ul>\n",
    "<li>Persistence diagrams are a summary for the geometry/topology of the sliding window embedding</li>\n",
    "<li>Maximum persistence is maximized when window size is close to period</li>\n",
    "<li>Surprisingly, the maximum persistence of signals with harmonics depends on the field of coefficients</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}