PythonTDA_Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Tutorial on Topological Data Analysis\n",
    "\n",
    "## Elizabeth Munch\n",
    " Dept of Computational Mathematics, Science and Engineering\n",
    " Dept of Mathematics\n",
    " Michigan State University"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "# Welcome\n",
    "\n",
    "This notebook is meant to be a first step introduction to some available tools for computation of TDA signatures using python.  This repository includes the jupyter notebooks for the 2021 Workshop [\"Mathematical and Computational Methods for Complex Social Systems\"](https://www.google.com/url?q=https://meetings.ams.org/math/sc2021/meetingapp.cgi) to be held at the virtual JMM 2021, led by [Elizabeth Munch](http://elizabethmunch.com/). This introduction is tailored for a network science audience, so the focus is on an relevant tools when given a network input.\n",
    "\n",
    "These slides are written to be presented as [RISE slides](https://rise.readthedocs.io/en/stable/index.html), however the notebook should be self contained without needing this installed. If you see a lot of weird cell toolbars in the notebook (which are used for controlling the slideshow version), these can be removed from your view of the jupyter notebook by going to View -> Cell Toolbar -> None\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Goals\n",
    "\n",
    "- Give a brief overview of available packages\n",
    "- Provide pipelines for computing persistent homology for input data such as a discrete metric space and a weighted graph. \n",
    "- Give you a place to start....\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "# Things I won't get to\n",
    "\n",
    "- Every possible filtration\n",
    "- Graphical signatures of data\n",
    "  - Reeb graphs\n",
    "  - Mapper graphs \n",
    "  - Merge trees\n",
    "  - Contour trees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Options to follow along\n",
    "\n",
    "\n",
    "\n",
    "- Download from the github repo: [github.com/lizliz/TDA-Python-Workshop-JMM21](https://github.com/lizliz/TDA-Python-Workshop-JMM21)\n",
    "- Run directly from binder: [tinyurl.com/jmm-tda](https://tinyurl.com/jmm-tda)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# An incomplete list of available software\n",
    "\n",
    "There are so many.....\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "New packages are being developed incredibly quickly.  I'm so happy to see the field taking off so fast.  That being said, I am choosing to use some of the packages I am most familiar with, which does not mean they will be the best option for your task. An incomplete and almost immeidately outdated list of available options is below. Any ommissions are uninentional. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- [SciKitTDA](https://scikit-tda.org/) by Nataniel Saul and Chris Tralie\n",
    "- [Teaspoon](http://elizabethmunch.com/code/teaspoon/index.html) By Liz Munch and Firas Khasawneh\n",
    "\n",
    "\n",
    "- [Ripser](https://github.com/Ripser/ripser) by Ulrich Bauer (C++)\n",
    "- [GUDHI](http://gudhi.gforge.inria.fr/) developed at INRIA\n",
    "- [Giotto-tda](https://giotto-ai.github.io/) developted at EPFL\n",
    "- [Cubicle](https://bitbucket.org/hubwag/cubicle/src/master/) by Hubert Wagner\n",
    "- [HomcCube](https://i-obayashi.info/software.html) By Ippei Obayashi.\n",
    "- [DIPHA](https://github.com/DIPHA/dipha) by Ulrich Bauer and Michael Kerber\n",
    "- [diamorse](https://github.com/AppliedMathematicsANU/diamorse) developed at The Australian National University.\n",
    "- [Perseus](http://people.maths.ox.ac.uk/nanda/perseus/) by Vidit Nanda\n",
    "- [Dionysus2](https://www.mrzv.org/software/dionysus2/) by Dimitry Morozov (C++, Python)\n",
    "- [CliqueTop](https://github.com/nebneuron/clique-top) by Chad Giusti (Matlab)\n",
    "- [Eirene](http://gregoryhenselman.org/eirene/index.html) by Greg Henselman (Julia)\n",
    "- [Ripser-live](http://live.ripser.org/)  by Ulrich Bauer (browser)\n",
    "- [CHomP](https://github.com/shaunharker/CHomP\") by Shaun Harker (C++) \n",
    "- [Hera](https://bitbucket.org/grey_narn/hera) by Michael Kerber, Dmitriy Morozov, and Arnur Nigmetov\n",
    "- [JavaPlex](https://github.com/appliedtopology) by Andrew Tausz, Mikael Vejdemo-Johansson and Henry Adams\n",
    "- [PHAT](https://bitbucket.org/phat-code/phat) by Ulrich Bauer, Michael Kerber, Jan Reininghaus, Hubert Wagner, and Bryn Keller\n",
    "-    <a href=\"https://topology-tool-kit.github.io/\" target=\"_blank\">Topology ToolKit</a>&nbsp;(C++) by&nbsp;Julien Tierny, Guillaume Favelier, Joshua Levine, Charles Gueunet, and Micha&euml;l Michaux (I think?)\n",
    "-   <a href=\"https://cran.r-project.org/web/packages/TDA/index.html\" target=\"_blank\">TDA</a>&nbsp;(R)&nbsp;by&nbsp;Brittany T. Fasy, Jisu Kim, Fabrizio Lecci, and Cl&eacute;ment Maria\n",
    "-    <a href=\"https://github.com/paultpearson/TDAmapper\" target=\"_blank\">TDAMapper </a>(R) by&nbsp;Paul Pearson, Daniel M&uuml;ellner, and Gurjeet Singh\n",
    "-    <a href=\"https://people.clas.ufl.edu/peterbubenik/intro-to-tda/\" target=\"_blank\">R scripts for TDA</a>&nbsp;by Peter Bubenik\n",
    "-    <a href=\"https://github.com/nebneuron/Simplicial\" target=\"_blank\">Simplicial complexes for Julia</a> by Alex Kunin and Vladimir Itskov\n",
    "-    <a href=\"http://web.cse.ohio-state.edu/~dey.8/SimBa/Simba.html\" target=\"_blank\">SimBa</a>&nbsp;and&nbsp;<a href=\"http://web.cse.ohio-state.edu/~dey.8/SimPers/Simpers.html\" target=\"_blank\">SimPer</a>&nbsp;(C++) by&nbsp;Tamal K Dey, &nbsp;Fengtao Fan, &nbsp;Dayu Shi, &nbsp;and Yusu Wan&nbsp;\n",
    "- <a href=\"http://danifold.net/mapper/index.html\" target=\"_blank\">Python Mapper</a>&nbsp;(Python) by&nbsp;Daniel M&uuml;llner and Aravindakshan Babu\n",
    "-    <a href=\"https://www.math.upenn.edu/~dlotko/persistenceLandscape.html\" target=\"_blank\">Persistence Landscape Toolbox</a>&nbsp;(C++) by Pawel Dlotko&#8203;\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Basic imports \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "import networkx as nx\n",
    "from IPython.display import Video\n",
    "\n",
    "# scikit-tda imports..... Install all with -> pip install scikit-tda\n",
    "#--- this is the main persistence computation workhorse\n",
    "import ripser\n",
    "# from persim import plot_diagrams\n",
    "import persim\n",
    "# import persim.plot\n",
    "\n",
    "# teaspoon imports...... Install with -> pip install teaspoon\n",
    "#---these are for generating data and some drawing tools \n",
    "import teaspoon.MakeData.PointCloud as makePtCloud\n",
    "import teaspoon.TDA.Draw as Draw\n",
    "\n",
    "#---these are for generating time series network examples\n",
    "from teaspoon.SP.network import ordinal_partition_graph\n",
    "from teaspoon.TDA.PHN import PH_network\n",
    "from teaspoon.SP.network_tools import make_network\n",
    "from teaspoon.parameter_selection.MsPE import MsPE_tau\n",
    "import teaspoon.MakeData.DynSysLib.DynSysLib as DSL\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Computing persistence on a point cloud\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Basic version: point clouds in $\\mathbb{R}^n$ inheriting Euclidean metric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Annulus example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "r = 1\n",
    "R = 2\n",
    "P = makePtCloud.Annulus(N=200, r=r, R=R, seed=None) # teaspoon data generation\n",
    "plt.scatter(P[:,0],P[:,1])\n",
    "# print(P)\n",
    "# print(type(P))\n",
    "# print(P.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    ".... run me for some nice drawings in a bit ...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Some quick code to draw stuff without showing all the matplotlib junk in the slides everytime. \n",
    "\n",
    "def drawTDAtutorial(P,diagrams, R = 2):\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=3, figsize = (20,5))\n",
    "\n",
    "    # Draw point cloud \n",
    "    plt.sca(axes[0])\n",
    "    plt.title('Point Cloud')\n",
    "    plt.scatter(P[:,0],P[:,1])\n",
    "\n",
    "    # Draw diagrams\n",
    "    plt.sca(axes[1])\n",
    "    plt.title('0-dim Diagram')\n",
    "    Draw.drawDgm(diagrams[0])\n",
    "\n",
    "    plt.sca(axes[2])\n",
    "    plt.title('1-dim Diagram')\n",
    "    Draw.drawDgm(diagrams[1])\n",
    "    plt.axis([0,R,0,R])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "diagrams = ripser.ripser(P)['dgms']\n",
    "\n",
    "# Draw stuff\n",
    "drawTDAtutorial(P,diagrams)  # Script included in notebook for drawing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Storage of diagrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Some discussion of how diagrams are stored \n",
    "data = ripser.ripser(P)\n",
    "# print(data.keys())\n",
    "# print(data['dgms'])\n",
    "data['dgms'][1]\n",
    "# len(data['dgms'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Cube example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "P = makePtCloud.Cube()\n",
    "diagrams = ripser.ripser(P)['dgms']\n",
    "\n",
    "# Draw stuff\n",
    "drawTDAtutorial(P,diagrams,R=0.8) # Script for drawing everything, code included in notebook\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Double annulus example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Make a quick double annulus\n",
    "\n",
    "def DoubleAnnulus(r1 = 1, R1 = 2, r2 = .8, R2 = 1.3, xshift = 3):\n",
    "    P = makePtCloud.Annulus(r = r1, R = R1)\n",
    "    Q = makePtCloud.Annulus(r = r2, R = R2)\n",
    "    Q[:,0] = Q[:,0] + xshift\n",
    "    P = np.concatenate((P, Q) )\n",
    "    return(P)\n",
    "\n",
    "P = DoubleAnnulus(r1 = 1, R1 = 2, r2 = .5, R2 = 1.3, xshift = 3) \n",
    "plt.scatter(P[:,0], P[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "P = DoubleAnnulus(r1 = 1, R1 = 2, r2 = .5, R2 = 1.3, xshift = 3) # Code included in notebook\n",
    "diagrams = ripser.ripser(P)['dgms']\n",
    "\n",
    "# Draw stuff\n",
    "drawTDAtutorial(P,diagrams,R=2.5) # Script for drawing everything, code included in notebook\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Computing Persistence on a Pairwise Distance/Similarity Matrix \n",
    "\n",
    "For this tutorial, we will always use the clique complex, but there are other options available.\n",
    "\n",
    "Some examples of when we might want to compute persistence in this way:\n",
    "\n",
    "- Input data with a distance/similarity matrix\n",
    "- Weighted graph where we set distance between non adjacent vertices to be np.inf- "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Computing persistence for a weighted graph as the 1-skeleton\n",
    "\n",
    "-Given a weighted graph $G$, get a filtration by keeping all edges with value $\\leq a$, then computing the clique complex.\n",
    "\n",
    "-Most useful/interesting when we have a decently dense graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### An overly simple example\n",
    "\n",
    "Given a pairwise similarity matrix $D$.\n",
    "\n",
    "Build the clique complex of the filtration induced by including edges in increasing order of weight.\n",
    "\n",
    "<img src=\"figures/WeightedGraphCliqueExample.png\" alt=\"Simple example\" style=\"width:500px\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"figures/WeightedGraphCliqueExample.png\" alt=\"Simple example\" style=\"width:300px\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Generate the distance matrix from the previous example\n",
    "D = np.array([[0, 1, np.inf, np.inf, 6],  [0, 0, 5, np.inf, np.inf],  [0, 0, 0, 2, 4],  [0, 0, 0, 0, 3],  [0, 0, 0, 0, 0]])\n",
    "D = D+D.T\n",
    "print(D)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Compute the persistence diagram, the key here is the `distance_matrix=True` bit since otherwise, ripser would think that `D` is a point cloud of $n$ $n$-dimensional points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "diagrams = ripser.ripser(D, distance_matrix=True, maxdim=1)['dgms']\n",
    "print('0-Dim Diagram')\n",
    "print(diagrams[0])\n",
    "print('1-Dim Diagram')\n",
    "print(diagrams[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### A bigger example with an Erdos-Renyii random graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "... run me for drawing nicely later ...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Drawing script for weighted graph\n",
    "def drawGraphEx(G):\n",
    "    #draw it!\n",
    "\n",
    "    pos = nx.spring_layout(G)  # positions for all nodes - seed for reproducibility\n",
    "\n",
    "    # nodes\n",
    "    nx.draw_networkx_nodes(G, pos, node_size=70)\n",
    "\n",
    "    # edges\n",
    "    nx.draw_networkx_edges(G, pos,  width=2)\n",
    "    # nx.draw_networkx_edges(\n",
    "    #     G, pos, edgelist=esmall, width=6, alpha=0.5, edge_color=\"b\", style=\"dashed\"\n",
    "    # )\n",
    "\n",
    "    # labels\n",
    "    # nx.draw_networkx_labels(G, pos, font_size=20, font_family=\"sans-serif\")\n",
    "    edge_labels=nx.draw_networkx_edge_labels(G,pos,edge_labels=nx.get_edge_attributes(G, 'weight'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "n = 10\n",
    "p = .3\n",
    "\n",
    "# Generate random graph \n",
    "G = nx.erdos_renyi_graph(n, p, seed=None, directed=False)\n",
    "\n",
    "m = len(G.edges)\n",
    "print('There are', m,'edges.')\n",
    "\n",
    "# Generate random edge weights in the interval [0,maxWeight]\n",
    "maxWeight = 100\n",
    "weights = np.random.randint(maxWeight, size = m)\n",
    "\n",
    "for i, e in enumerate(G.edges()):\n",
    "    G[e[0]][e[1]] ['weight'] = weights[i]\n",
    "    \n",
    "drawGraphEx(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "A = nx.adjacency_matrix(G, weight = 'weight')\n",
    "A = A.todense() # Turn into dense matrix for ease of messing with it\n",
    "A = np.array(A) # Apparently I need to hand scikit-tda an array instead of a matrix, don't know why\n",
    "A = A.astype('float64') # Needed to let me put in np.inf\n",
    "A[ np.where(A == 0)] = np.inf\n",
    "np.fill_diagonal(A,0)\n",
    "\n",
    "im = plt.matshow(A, vmax = 100) # Note the np.inf values show up as white\n",
    "plt.colorbar(im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "diagrams = ripser.ripser(A, distance_matrix=True)['dgms']\n",
    "persim.plot_diagrams(diagrams)\n",
    "# print(diagrams)\n",
    "# print(diagrams)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### An example from networks computed from time series embeddings \n",
    "\n",
    "- [Persistent Homology of Complex Networks for Dynamic State Detection. *Audun Myers, Elizabeth Munch, and Firas A. Khasawneh*. Physical Review E, 2019](https://doi.org/10.1103/PhysRevE.100.022314)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Video(\"figures/OrdinalPartitionNetworkExample_AudunMyers.mp4\", width = 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "... run me for drawing stuff later..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Code to draw the next example later, here so it doesn't end up in a slide\n",
    "def drawNetworkExample(gs,G,diagram):\n",
    "    TextSize = 14\n",
    "    plt.figure(2)\n",
    "    plt.figure(figsize=(8,8))\n",
    "    gs = gridspec.GridSpec(4, 2)\n",
    "\n",
    "    ax = plt.subplot(gs[0:2, 0:2]) #plot time series\n",
    "    plt.title('Time Series', size = TextSize)\n",
    "    plt.plot(ts, 'k')\n",
    "    plt.xticks(size = TextSize)\n",
    "    plt.yticks(size = TextSize)\n",
    "    plt.xlabel('$t$', size = TextSize)\n",
    "    plt.ylabel('$x(t)$', size = TextSize)\n",
    "    plt.xlim(0,len(ts))\n",
    "\n",
    "    ax = plt.subplot(gs[2:4, 0])\n",
    "    plt.title('Network', size = TextSize)\n",
    "    nx.draw(G, pos, with_labels=False, font_weight='bold', node_color='blue',\n",
    "            width=1, font_size = 10, node_size = 30)\n",
    "\n",
    "    ax = plt.subplot(gs[2:4, 1])\n",
    "    plt.title('Persistence Diagram', size = TextSize)\n",
    "    MS = 3\n",
    "    top = max(diagram[1].T[1])\n",
    "    plt.plot([0,top*1.25],[0,top*1.25],'k--')\n",
    "    plt.yticks( size = TextSize)\n",
    "    plt.xticks(size = TextSize)\n",
    "    plt.xlabel('Birth', size = TextSize)\n",
    "    plt.ylabel('Death', size = TextSize)\n",
    "    plt.plot(diagram[1].T[0],diagram[1].T[1] ,'go', markersize = MS+2)\n",
    "    plt.xlim(0,top*1.25)\n",
    "    plt.ylim(0,top*1.25)\n",
    "\n",
    "    plt.subplots_adjust(hspace= 0.8)\n",
    "    plt.subplots_adjust(wspace= 0.35)\n",
    "    plt.show()\n",
    "    \n",
    "def drawThisDiagram(diagram):\n",
    "    TextSize = 14\n",
    "    plt.title('Persistence Diagram', size = TextSize)\n",
    "    MS = 3\n",
    "    top = max(diagram[1].T[1])\n",
    "    plt.plot([0,top*1.25],[0,top*1.25],'k--')\n",
    "    plt.yticks( size = TextSize)\n",
    "    plt.xticks(size = TextSize)\n",
    "    plt.xlabel('Birth', size = TextSize)\n",
    "    plt.ylabel('Death', size = TextSize)\n",
    "    plt.plot(diagram[1].T[0],diagram[1].T[1] ,'go', markersize = MS+2)\n",
    "    plt.xlim(0,top*1.25)\n",
    "    plt.ylim(0,top*1.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#generate time series\n",
    "system = 'rossler'\n",
    "dynamic_state = 'periodic'\n",
    "t, solution = DSL.DynamicSystems(system, dynamic_state)\n",
    "ts = solution[1]\n",
    "\n",
    "plt.plot(t,ts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#Get appropriate dimension and delay parameters for permutations\n",
    "tau = int(MsPE_tau(ts))\n",
    "n = 5\n",
    "\n",
    "#create adjacency matrix, this\n",
    "A = ordinal_partition_graph(ts, n, tau)\n",
    "\n",
    "#get networkx representation of network for plotting\n",
    "G, pos = make_network(A, position_iterations = 2000, remove_deg_zero_nodes = True)\n",
    "\n",
    "nx.draw(G, pos, with_labels=False, font_weight='bold', node_color='blue',\n",
    "            width=1, font_size = 10, node_size = 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#create distance matrix and calculate persistence diagram\n",
    "D, diagram = PH_network(A, method = 'unweighted', distance = 'shortest_path')\n",
    "# print('1-D Persistent Homology (loops): \\n', diagram[1])\n",
    "drawNetworkExample(ts,G,diagram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The same example but with a chaotic time series "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "#generate time series\n",
    "system = 'rossler'\n",
    "dynamic_state = 'chaotic'\n",
    "t, solution = DSL.DynamicSystems(system, dynamic_state)\n",
    "ts = solution[1]\n",
    "\n",
    "#Get appropriate dimension and delay parameters for permutations\n",
    "tau = int(MsPE_tau(ts))\n",
    "n = 5\n",
    "\n",
    "#create adjacency matrix, this\n",
    "A = ordinal_partition_graph(ts, n, tau)\n",
    "\n",
    "#get networkx representation of network for plotting\n",
    "G, pos = make_network(A, position_iterations = 2000, remove_deg_zero_nodes = True)\n",
    "\n",
    "#create distance matrix and calculate persistence diagram\n",
    "D, diagram = PH_network(A, method = 'unweighted', distance = 'shortest_path')\n",
    "# print('1-D Persistent Homology (loops): \\n', diagram[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "drawNetworkExample(ts,G,diagram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Warning\n",
    "\n",
    "Persistence diagrams can have multiplicity!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# print('1-D Persistent Homology (loops): \\n', diagram[1]) # Uncomment me!\n",
    "drawThisDiagram(diagram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Distances between persistence diagrams "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Make three example point clouds \n",
    "r = 1\n",
    "R = 2\n",
    "P1 = makePtCloud.Annulus(N=200, r=r, R=R, seed=None) # teaspoon data generation\n",
    "P2 = makePtCloud.Annulus(N=200, r=r, R=R, seed=None)\n",
    "P2[:,1] += 6\n",
    "P3 = DoubleAnnulus()\n",
    "P3 *= 1.1\n",
    "P3[:,0] += 6\n",
    "P3[:,1] += 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# plt.figure(figsize = (15,5))\n",
    "plt.scatter(P1[:,0],P1[:,1], label = 'P1')\n",
    "plt.scatter(P2[:,0],P2[:,1], label = 'P2')\n",
    "plt.scatter(P3[:,0],P3[:,1], label = 'P3')\n",
    "plt.axis('equal')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Compute their diagrams \n",
    "diagrams1 = ripser.ripser(P1)['dgms']\n",
    "diagrams2 = ripser.ripser(P2)['dgms']\n",
    "diagrams3 = ripser.ripser(P3)['dgms']\n",
    "\n",
    "Draw.drawDgm(diagrams1[1])\n",
    "Draw.drawDgm(diagrams2[1])\n",
    "Draw.drawDgm(diagrams3[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Bottleneck Distance "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Compute bottleneck distance using scikit-tda\n",
    "distance_bottleneck, (matching, D) = persim.bottleneck(diagrams1[1], diagrams2[1], matching=True)\n",
    "persim.visuals.bottleneck_matching(diagrams1[1], diagrams2[1], matching, D, labels=['Clean $H_1$', 'Noisy $H_1$'])\n",
    "print('The bottleneck distance is', distance_bottleneck)\n",
    "# print(matching)\n",
    "# print(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Compute bottleneck of P1 and P3\n",
    "distance_bottleneck, (matching, D) = persim.bottleneck(diagrams1[1], diagrams3[1], matching=True)\n",
    "persim.visuals.bottleneck_matching(diagrams1[1], diagrams3[1], matching, D, labels=['Clean $H_1$', 'Noisy $H_1$'])\n",
    "print('The bottleneck distance is', distance_bottleneck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# But Liz, what should I do next? \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "Ha I have no idea! But here are some next steps to read about/try.  Happy to discuss more during the small group session! \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Different input data and/or filtrations\n",
    "  - Something other than clique complexes\n",
    "  - Directed complexes \n",
    "  - Image data \n",
    "- ML and statistics interfaces: featurizations \n",
    "  - [Persistence images](https://www.jmlr.org/papers/v18/16-337.html)\n",
    "  - [Persistence landscapes](https://www.jmlr.org/papers/volume16/bubenik15a/bubenik15a.pdf)\n",
    "  - [Template functions](https://arxiv.org/abs/1902.07190)\n",
    "  - Lots and lots more......\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "  \n",
    "- Other TDA signatures \n",
    "  - Reeb graphs\n",
    "  - [Mapper graphs ](https://research.math.osu.edu/tgda/mapperPBG.pdf)\n",
    "  - Merge trees\n",
    "  - Contour trees \n",
    "  - Morse-Smale complexes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "<style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;}\n",
    ".tg td{border-color:white;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
    "  overflow:hidden;padding:10px 5px;word-break:normal;}\n",
    ".tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
    "  font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}\n",
    ".tg .tg-baqh{text-align:center;vertical-align:top}\n",
    "\n",
    "</style>\n",
    "\n",
    "# Thank you!!!\n",
    "\n",
    "- Content adapted from tutorials by [Audun Myers](https://www.audunmyers.com/) and [Chris Tralie](http://www.ctralie.com/)\n",
    "- Get connected: [WinCompTop](https://awmadvance.org/research-networks/wincomptop-women-in-computational-topology/)\n",
    "- My survey papers:  [User's guide](https://learning-analytics.info/index.php/JLA/article/view/5196),    [Bio focus](https://anatomypubs.onlinelibrary.wiley.com/doi/full/10.1002/dvdy.175)\n",
    "\n",
    "<table class=\"tg\">\n",
    "\n",
    "<tbody>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">\n",
    "        <img src = \"https://evacenteno.com/wp-content/uploads/2015/08/icon-blue-email-294x300.png\" alt = \"email icon\" style=\"width:30px;\"/>\n",
    "        <a href=\"mailto:muncheli@msu.edu\">muncheli@msu.edu</a>\n",
    "    </td>\n",
    "    <td class=\"tg-baqh\">\n",
    "        <img src = \"https://www.flaticon.com/svg/static/icons/svg/975/975645.svg\" alt = \"Website icon\" style=\"width:30px;\"/>\n",
    "        <a href=\"http://elizabethmunch.com\">elizabethmunch.com</a>\n",
    "    </td>\n",
    "    <td class=\"tg-baqh\">\n",
    "        <img src = \"https://www.flaticon.com/svg/static/icons/svg/220/220233.svg\" alt=\"Twitter icon\"style=\"width:30px;\"/>\n",
    "        <a href=\"https://twitter.com/elizabethmunch\">@elizabethmunch</a>\n",
    "    </td>\n",
    "    <td>\n",
    "        <img src=\"https://www.nsf.gov/images/logos/NSF_4-Color_vector_Logo_thumb.jpg\" alt=\"NSF Logo\" style=\"width:80px\">\n",
    "      </td>\n",
    "          <td>\n",
    "        <img src=\"https://cmse.msu.edu/sites/_cmse/assets/Image/image002.jpg\" alt=\"MSU CMSE Logo\" style=\"width:80px\">\n",
    "      </td>\n",
    "       \n",
    "  </tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "\n"
   ]
  },
  {
   "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": 4
}