atari-anomaly.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = 'Breakout'\n",
    "num_episodes = 25 #use them all?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import anomapy.train.sssn as sssn\n",
    "import pyworld.toolkit.tools.visutils.transform as T\n",
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import pyworld.toolkit.tools.torchutils as tu\n",
    "\n",
    "def distance(model, episode):\n",
    "    z, d = sssn.distance(model, episode)\n",
    "    return tu.to_numpy(z), tu.to_numpy(d)\n",
    "    \n",
    "def plot_latent(model, episode):\n",
    "    z = tu.to_numpy(sssn.encode(model, episode))\n",
    "    images = T.HWC(tu.to_numpy(episode))\n",
    "    return J.scatter_image(z[:,0], z[:,1], images, scatter_colour='blue', line_colour='#b9d1fa', scale=1.5)\n",
    "\n",
    "def order_by(model, episode):\n",
    "    d, z = distance(model, episode)\n",
    "    images = T.HWC(tu.to_numpy(episode))\n",
    "    i = np.argsort(-d)\n",
    "    return d[i], images[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import datasets\n",
    "from pprint import pprint\n",
    "import numpy as np\n",
    "\n",
    "dataset = datasets.dataset('aad.raw.{0}'.format(env))\n",
    "dataset.state.transform.to_float().CHW().torch()\n",
    "episodes = [x for x in dataset.state.load(num_episodes)]\n",
    "for i,e in enumerate(episodes):\n",
    "    print(\"episode:\", i, e.shape)\n",
    "    \n",
    "print(np.sum([e.shape[0] for e in episodes]))\n",
    "    \n",
    "episode_test = episodes[-1]\n",
    "episodes = episodes[:-1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from types import SimpleNamespace\n",
    "\n",
    "import pyworld.toolkit.tools.wbutils as wbu\n",
    "import pyworld.toolkit.tools.fileutils as fu\n",
    "import pyworld.toolkit.tools.torchutils as tu\n",
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "\n",
    "import anomapy.train.sssn as sssn\n",
    "\n",
    "CONFIG = sssn.default_config()\n",
    "CONFIG.update(dataset.meta.to_dict())\n",
    "CONFIG['latent_shape'] = 256\n",
    "CONFIG['epochs'] = 12\n",
    "CONFIG['batch_size'] = 128\n",
    "CONFIG['total_states'] = sum([e.shape[0] for e in episodes])\n",
    "CONFIG['episodes'] = len(episodes)\n",
    "CONFIG = SimpleNamespace(**CONFIG)\n",
    "\n",
    "print(CONFIG)\n",
    "\n",
    "DRYRUN = True\n",
    "PROJECT = \"anomaly-detection\"\n",
    "RUN_ID = \"{0}-{1}-{2}\".format(CONFIG.model, CONFIG.name, fu.file_datetime())\n",
    "RUN_TAGS = [CONFIG.model, CONFIG.name]\n",
    "\n",
    "wbu.dryrun(DRYRUN)\n",
    "\n",
    "optimiser = sssn.new(dryrun=DRYRUN, **CONFIG.__dict__)\n",
    "model = optimiser.model\n",
    "\n",
    "wb = wbu.WB(PROJECT, model, id=RUN_ID, tags=RUN_TAGS, config=CONFIG.__dict__)\n",
    "#loss_plot = J.dynamic_plot(update_after=10)\n",
    "\n",
    "#z = tu.to_numpy(sssn.encode(model, episodes[0]))\n",
    "#plot = J.plot(z[:,0], z[:,1], mode=J.line_mode.both)\n",
    "\n",
    "with wb:\n",
    "    for i in range(CONFIG.epochs):\n",
    "        print(\"---- epoch: \", i)\n",
    "        for episode in episodes:\n",
    "            for loss in sssn.epoch(optimiser, episode, CONFIG.batch_size):\n",
    "                pass #loss_plot.update(None, loss['loss'])\n",
    "            #z = tu.to_numpy(sssn.encode(model, episodes[0]))\n",
    "            #plot.set_data(z[:,0], z[:,1])\n",
    "            print(\"loss:\", optimiser.cma())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from types import SimpleNamespace\n",
    "import anomapy.train.sssn as sssn\n",
    "import pyworld.toolkit.tools.wbutils as wbu\n",
    "\n",
    "\n",
    "def distance(model, episode):\n",
    "    z, d = sssn.distance(model, episode)\n",
    "    return tu.to_numpy(z), tu.to_numpy(d)\n",
    "\n",
    "\n",
    "env = \"Breakout\"\n",
    "dryruns = sorted([r for r in wbu.dryruns() if env in r])\n",
    "print(dryruns[-1])\n",
    "\n",
    "models, config = wbu.load(dryruns[-1]) #load the most recently trained model\n",
    "model = models['model.pt'].load(sssn.model(**config))\n",
    "config = SimpleNamespace(**config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Anomalies\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datasets\n",
    "\n",
    "dataset = datasets.dataset('aad.anomaly.{0}'.format(env))\n",
    "dataset.state.transform.to_float().CHW().torch()\n",
    "anoms = [(a,e[0]) for a,e in dataset.meta.anomaly.items()]\n",
    "a_episodes = [d for d in dataset.state.load_files(*[e[1] for e in anoms])]\n",
    "a_labels = [d for d in dataset.label.load_files(*[e[1] for e in anoms])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a_tlabels = [np.logical_or(l[:-1], l[1:]).astype(np.uint8) for l in a_labels] #transition labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ROC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "from sklearn.metrics import auc\n",
    "\n",
    "\n",
    "import plotly\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "import pyworld.toolkit.tools.visutils.transform as T\n",
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import pyworld.toolkit.tools.visutils.plot as vplot\n",
    "import pyworld.toolkit.tools.torchutils as tu\n",
    "import pyworld.toolkit.tools.fileutils as fu\n",
    "\n",
    "import numpy as n\n",
    "from pprint import pprint\n",
    "\n",
    "def roc(label, score):\n",
    "    assert label.shape[0] == score.shape[0]\n",
    "    fpr, tpr, _ = roc_curve(label, score)\n",
    "   \n",
    "    return fpr, tpr\n",
    "\n",
    "fprs = []\n",
    "tprs = []\n",
    "aucs = {}\n",
    "legend = []\n",
    "for i in range(len(a_episodes[:-1])):\n",
    "    episode = a_episodes[i]\n",
    "    anomaly = anoms[i][0]\n",
    "    label = a_tlabels[i]\n",
    "    _, score = distance(model, episode)\n",
    "    \n",
    "    fpr, tpr, _ = roc_curve(label, score)\n",
    "    aucs[anomaly] = auc(fpr, tpr)\n",
    "    fprs.append(fpr)\n",
    "    tprs.append(tpr)\n",
    "    legend.append(anomaly)\n",
    "\n",
    "pprint(aucs)\n",
    "legend[0] = 'flicker'\n",
    "legend[1] = 'visual artefact'\n",
    "legend = [l.replace('_', ' ') for l in legend]\n",
    "print(legend)\n",
    "\n",
    "plot = J.plot(fprs, tprs, legend=legend, show=False)\n",
    "plot.fig.update_layout(showlegend=True, autosize=False, width=300, height=280, margin=dict(l=5,b=5,r=5,t=5))\n",
    "plot.fig.update_layout(dict(legend=dict(xanchor='center', x=0.5, orientation='h')))\n",
    "\n",
    "#path = \"/home/ben/Downloads/rocs/\"\n",
    "#plot.fig.write_image(path + \"{0}.png\".format(env))\n",
    "#fu.save(path + \"{0}.json\".format(env), aucs)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "anoms[0] = ('flicker', anoms[1])\n",
    "anoms[1] = ('visual artefact', anoms[1])\n",
    "anoms = [(a[0].replace('_',' '), a[1]) for a in anoms]\n",
    "for a in anoms:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.transform as T\n",
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import pyworld.toolkit.tools.visutils.plot as vplot\n",
    "import pyworld.toolkit.tools.torchutils as tu\n",
    "import pyworld.toolkit.tools.datautils as du\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "import plotly\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "\n",
    "subplot = plotly.subplots.make_subplots(rows=3,cols=2, vertical_spacing = 0.08, horizontal_spacing = 0.05, subplot_titles=[a[0] for a in anoms[:-1]])\n",
    "\n",
    "\n",
    "\n",
    "showlegend = True\n",
    "\n",
    "def histogram(model, episode, labels, title, i, j, bins=50):\n",
    "    z, d = distance(model, episode)\n",
    "    d = du.normalise(d)\n",
    "    \n",
    "    \n",
    "    d_a = d[labels==1]\n",
    "    d_n = d[labels==0]\n",
    "    print(d.shape, d_a.shape, d_n.shape)\n",
    "    binsize = (np.max(d) - np.min(d)) / bins\n",
    "    print(\"anomaly count: \", d_a.shape[0], \"normal count: \", d_n.shape[0])\n",
    "    subplot.add_trace(go.Histogram(x=d_a, marker=dict(color='red'), name='anomaly', showlegend=showlegend, xbins=dict(size=binsize)), row=i, col=j)\n",
    "    subplot.add_trace(go.Histogram(x=d_n, marker=dict(color='blue'), name='normal', showlegend=showlegend, xbins=dict(size=binsize)), row=i, col=j)\n",
    "\n",
    "histogram(model, a_episodes[0], a_tlabels[0], anoms[0], 1, 1)\n",
    "showlegend=False\n",
    "histogram(model, a_episodes[1], a_tlabels[1], anoms[1], 1, 2)\n",
    "histogram(model, a_episodes[2], a_tlabels[2], anoms[2], 2, 1)\n",
    "histogram(model, a_episodes[3], a_tlabels[3], anoms[3], 2, 2)\n",
    "histogram(model, a_episodes[4], a_tlabels[4], anoms[4], 3, 1)\n",
    "histogram(model, a_episodes[5], a_tlabels[5], anoms[5], 3, 2)\n",
    "\n",
    "subplot.update_layout(yaxis_type=\"log\")\n",
    "subplot.update_layout(yaxis2_type=\"log\")\n",
    "subplot.update_layout(yaxis3_type=\"log\")\n",
    "subplot.update_layout(yaxis4_type=\"log\")\n",
    "subplot.update_layout(yaxis5_type=\"log\")\n",
    "subplot.update_layout(yaxis6_type=\"log\")\n",
    "#print(subplot)\n",
    "subplot.update_layout(margin=dict(l=5,b=0,r=5,t=20))\n",
    "subplot.update_layout(dict(legend=dict(xanchor='center', y = -0.03, x=0.5, orientation='h')))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualise Latent Space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert config.latent_shape == 2 #otherwise... hmmm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Distance Graphs\n",
    "Distance graphs are interactive and show the score (naturaly ordered) of each transition. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.transform as T\n",
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import pyworld.toolkit.tools.torchutils as tu\n",
    "import numpy as np\n",
    "import datasets\n",
    "\n",
    "def plot_distance(model, episode):\n",
    "    z, d = distance(model, episode)\n",
    "    images = T.HWC(tu.to_numpy(episode))\n",
    "\n",
    "    plot = J.SimplePlot(np.arange(len(d)), d)\n",
    "    image1 = J.SimpleImage(images[0])\n",
    "    image2 = J.SimpleImage(images[1])\n",
    "\n",
    "    def on_hover(trace, points, state):\n",
    "        i = points.point_inds[0]\n",
    "        image1.set_image(images[i])\n",
    "        image2.set_image(images[i+1])\n",
    "\n",
    "    plot.on_hover(on_hover)\n",
    "    d_images = J.layout_horizontal(image1.fig, image2.fig)\n",
    "    d_plot = J.layout_horizontal(plot.fig)\n",
    "    J.display(J.layout_vertical(d_plot, d_images))\n",
    "\n",
    "env = \"Pong\"\n",
    "dataset = datasets.dataset('aad.raw.{0}'.format(env))\n",
    "dataset.state.transform.to_float().CHW().torch()\n",
    "episode = [x for x in dataset.state.load(1)][0]\n",
    "plot_distance(model, episode)\n",
    "\n",
    "\"\"\"\n",
    "for i in range(len(a_episodes)):\n",
    "    a = anoms[i][0]\n",
    "    print(\"========================== {0} ==========================\".format(a))\n",
    "    plot_distance(model, a_episodes[i]) \n",
    "\"\"\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualise Anomalies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.transform as T\n",
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import pyworld.toolkit.tools.torchutils as tu\n",
    "import numpy as np\n",
    "\n",
    "for i in range(len(a_episodes)):\n",
    "    a = anoms[i][0]\n",
    "    print(a)\n",
    "    J.images(T.HWC(tu.to_numpy(a_episodes[i])))\n",
    "    #J.scatter(np.arange(len(a_labels[i])), a_labels[i])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load and show old 2D visualisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "from types import SimpleNamespace\n",
    "import anomapy.train.sssn as sssn\n",
    "import pyworld.toolkit.tools.wbutils as wbu\n",
    "import datasets\n",
    "import numpy as np\n",
    "\n",
    "#load model\n",
    "env = \"Breakout\"\n",
    "run = \"benedict-wilkins/anomapy/sssn-Breakout-20200209131829\"\n",
    "models, config = wbu.load(run)\n",
    "config['state'] = dict(shape=config['state_shape'])\n",
    "model = models['model.pt'].load(sssn.model(**config))\n",
    "config = SimpleNamespace(**config)\n",
    "\n",
    "#load data\n",
    "num_episodes = 1\n",
    "dataset = datasets.dataset('aad.raw.{0}'.format(env))\n",
    "dataset.state.transform.to_float().CHW().torch()\n",
    "episodes = [x for x in dataset.state.load(num_episodes)]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#visualise\n",
    "import anomapy.train.sssn as sssn\n",
    "import pyworld.toolkit.tools.visutils.transform as T\n",
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import pyworld.toolkit.tools.torchutils as tu\n",
    "\n",
    "a = 5\n",
    "episode = a_episodes[a]\n",
    "labels = a_labels[a].astype(np.uint8)\n",
    "print(labels)\n",
    "\n",
    "def plot_latent(model, episode):\n",
    "    z = tu.to_numpy(sssn.encode(model, episode))\n",
    "    images = T.HWC(tu.to_numpy(episode))\n",
    "    return J.scatter_image(z[:,0], z[:,1], images, scatter_colour=np.array(['blue','red'])[labels], line_colour='#b9d1fa', scale=1.5)\n",
    "\n",
    "from ipywidgets import Image, Layout, VBox, HBox, interact, IntSlider, IntProgress, HTML, Output\n",
    "import ipywidgets as widgets\n",
    "\n",
    "fig, image = plot_latent(model, episode)\n",
    "\n",
    "fig.update_layout(width=600, height=500)\n",
    "#box_layout = widgets.Layout(display='flex',flex_flow='row',align_items='center',width='100%',height='100%')\n",
    "#display(HBox([fig], layout=box_layout))\n",
    "\n",
    "#box_layout = widgets.Layout(display='flex',flex_flow='row',align_items='center',width='100%',height='100%')\n",
    "#display(HBox([fig, image_widget], layout=box_layout)) #basically... this needs to be done in jupyter..?!]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------\n",
    "-----------------\n",
    "-----------------\n",
    "-----------------\n",
    "\n",
    "# OTHER DEMOS\n",
    "\n",
    "\n",
    "#### dynamic plot example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import time\n",
    "import numpy as np\n",
    "\n",
    "loss_plot = J.dynamic_plot(update_after=100)\n",
    "\n",
    "for i in range(1000):\n",
    "    time.sleep(0.01)\n",
    "    loss_plot.update(i, np.sin(i/(np.pi*2)))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = tu.to_numpy(optimiser.encode(episode))\n",
    "images = T.HWC(tu.to_numpy(episode))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interactive plot example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import numpy as np\n",
    "\n",
    "x = np.arange(1000)\n",
    "y = np.sin(x)\n",
    "\n",
    "plot = J.SimplePlot(x,y)\n",
    "def on_hover(trace, points, state):\n",
    "    ind = points.point_inds[0]\n",
    "    print(ind)\n",
    "    \n",
    "plot.on_hover(on_hover)\n",
    "plot.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interactive plot with images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import numpy as np\n",
    "\n",
    "N = 100\n",
    "x = np.arange(N)\n",
    "y = np.sin(x)\n",
    "images = np.random.randint(0,255,size=(N, 100, 100, 3))\n",
    "image = J.SimpleImage(images[0])\n",
    "\n",
    "plot = J.SimplePlot(x,y)\n",
    "def on_hover(trace, points, state):\n",
    "    i = points.point_inds[0]\n",
    "    image.set_image(images[i])\n",
    "    \n",
    "plot.on_hover(on_hover)\n",
    "\n",
    "J.display(J.layout_horizontal(plot.fig, image.fig))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Sliding Histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import pyworld.toolkit.tools.visutils.plot as vplot\n",
    "import numpy as np\n",
    "\n",
    "N = 100\n",
    "x = np.arange(N)\n",
    "y = np.sin(x)\n",
    "yc = np.random.uniform(0,1,size=y.shape[0])\n",
    "\n",
    "fig = J.histogram([y,yc], show=False)\n",
    "vplot.histogram_slider(fig, sizes=np.arange(0.01,0.5,0.01))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "N = 100\n",
    "x = np.arange(N)\n",
    "y = np.sin(x)\n",
    "yc = np.random.uniform(0,1,size=y.shape[0])\n",
    "\n",
    "import plotly\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "def hist(x, color, name, showlegend=False):\n",
    "    return go.Histogram(x=x, marker=dict(color=color), name=name, showlegend=showlegend)\n",
    "\n",
    "c1 = 'red'\n",
    "c2 = 'blue'\n",
    "\n",
    "\n",
    "subplot = plotly.subplots.make_subplots(rows=3, cols=2)\n",
    "trace1 = subplot.add_trace(hist(x, c1, 'anomaly', showlegend=True), row=1, col=1)\n",
    "trace2 = subplot.add_trace(hist(y, c2, 'normal', showlegend=True), row=1, col=1)\n",
    "trace3 = subplot.add_trace(hist(yc, c1, 'anomaly'), row=1, col=2)\n",
    "\n",
    "subplot\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### change scatter colour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyworld.toolkit.tools.visutils.jupyter as J\n",
    "import numpy as np\n",
    "\n",
    "n = 10\n",
    "x = np.arange(n)\n",
    "y = np.sin(x)\n",
    "\n",
    "plot = J.SimplePlot(x,y,mode=J.line_mode.marker)\n",
    "def on_hover(trace, points, state):\n",
    "    ind = points.point_inds[0]\n",
    "    print(ind)\n",
    "    \n",
    "plot.on_hover(on_hover)\n",
    "#print(plot.fig)\n",
    "plot.fig.data[0]['marker'] = dict(color=np.random.randint(0,3,size=n).tolist())\n",
    "plot.display()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PhD",
   "language": "python",
   "name": "phd"
  },
  "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}