example_2_eye_movements_interactive.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quickstart\n",
    "To run the code below:\n",
    "\n",
    "1. Click on the cell to select it.\n",
    "2. Press `SHIFT+ENTER` on your keyboard or press the play button\n",
    "   (<button class='fa fa-play icon-play btn btn-xs btn-default'></button>) in the toolbar above.\n",
    "\n",
    "Feel free to create new cells using the plus button\n",
    "(<button class='fa fa-plus icon-plus btn btn-xs btn-default'></button>), or pressing `SHIFT+ENTER` while this cell\n",
    "is selected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example 2 (Smooth pursuit eye movements) – interactive version\n",
    "\n",
    "This is an interactive verison of the idealized model of the smooth pursuit reflex. This version does not explain the model itself, but shows how Brian's \"runtime mode\" can be used to interact with a running simulation. In this mode, the generated code based on the model descriptions is seemlessly integrated with the Python environment and can execute arbitrary Python code at any point during the simulation via a specially annotated function, called a \"network operation\".\n",
    "\n",
    "For a non-interactive version of this example which generates the article's figure see [this notebook](example_2_eye_movements.ipynb).\n",
    "\n",
    "**This version uses the *plotly* library for consistency with the other examples. However, updating an existing figure is slower than with the *matplotlib* library, so it is not an ideal solution for this example. For a version based on *matplotlib*, see [this notebook](example_2_eye_movements_interactive_matplotlib.ipynb)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Needs ipywidgets\n",
    "import ipywidgets as widgets\n",
    "import threading\n",
    "from brian2 import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model itself (mostly identical to the [non-interactive example](example_2_eye_movements.ipynb), except that some of the constants are included as parameters in the equation and can therefore change during the simulation):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = (1/(50*ms))**2 # characteristic relaxation time is 50 ms\n",
    "beta = 1/(50*ms) # friction parameter\n",
    "\n",
    "eqs_eye = '''\n",
    "dx/dt = velocity : 1\n",
    "dvelocity/dt = alpha*(x0-x)-beta*velocity : 1/second\n",
    "dx0/dt = -x0/tau_muscle : 1\n",
    "dx_object/dt = (noise - x_object)/tau_object:  1\n",
    "dnoise/dt = -noise/tau_object + tau_object**-0.5*xi : 1\n",
    "tau_object : second\n",
    "tau_muscle : second\n",
    "'''\n",
    "eye = NeuronGroup(1, model=eqs_eye, method='euler')\n",
    "taum = 20*ms\n",
    "motoneurons = NeuronGroup(2, model= 'dv/dt = -v/taum : 1', threshold = 'v>1',\n",
    "                          reset = 'v=0', refractory = 5*ms, method='exact')\n",
    "motosynapses = Synapses(motoneurons, eye, model = 'w : 1', on_pre = 'x0+=w')\n",
    "motosynapses.connect() # connects all motoneurons to the eye\n",
    "motosynapses.w = [-0.5,0.5]\n",
    "N = 20\n",
    "width = 2./N # width of receptive field\n",
    "gain = 4.\n",
    "eqs_retina = '''\n",
    "I = gain*exp(-((x_object-x_eye-x_neuron)/width)**2) : 1\n",
    "x_neuron : 1 (constant)\n",
    "x_object : 1 (linked) # position of the object\n",
    "x_eye : 1 (linked) # position of the eye\n",
    "dv/dt = (I-(1+gs)*v)/taum : 1\n",
    "gs : 1 # total synaptic conductance\n",
    "'''\n",
    "retina = NeuronGroup(N, model = eqs_retina, threshold = 'v>1', reset = 'v=0', method='exact')\n",
    "retina.v = 'rand()'\n",
    "retina.x_eye = linked_var(eye, 'x')\n",
    "retina.x_object = linked_var(eye, 'x_object')\n",
    "retina.x_neuron = '-1.0 + 2.0*i/(N-1)'\n",
    "sensorimotor_synapses = Synapses(retina, motoneurons, model = 'w : 1 (constant)', on_pre = 'v+=w')\n",
    "sensorimotor_synapses.connect(j = 'int(x_neuron_pre > 0)')\n",
    "sensorimotor_synapses.w = '20*abs(x_neuron_pre)/N_pre'\n",
    "M = StateMonitor(eye, ('x', 'x0', 'x_object'), record = True)\n",
    "S_retina = SpikeMonitor(retina)\n",
    "S_motoneurons = SpikeMonitor(motoneurons)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create an empty plot that will be updated during the run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotly import tools\n",
    "from plotly.offline import iplot, init_notebook_mode\n",
    "import plotly.graph_objs as go\n",
    "\n",
    "init_notebook_mode(connected=True)\n",
    "\n",
    "fig = tools.make_subplots(3, 1, specs=[[{'rowspan': 2}], [None], [{}]],\n",
    "                          shared_xaxes=True, print_grid=False)\n",
    "\n",
    "retina_spikes = go.Scattergl(x=[],\n",
    "                           y=[],\n",
    "                           marker={'symbol': 'line-ns', 'line': {'width': 1, 'color':'black'}},\n",
    "                           mode='markers',\n",
    "                           name='retina',\n",
    "                           showlegend=False)\n",
    "fig.append_trace(retina_spikes, 1, 1)\n",
    "left_spikes = go.Scattergl(x=[],\n",
    "                         y=[],\n",
    "                         marker={'symbol': 'line-ns', 'line': {'width': 1, 'color':'#1f77b4'},\n",
    "                                 'color':'#1f77b4'},\n",
    "                         mode='markers',\n",
    "                         name='left motoneuron',\n",
    "                         showlegend=False)\n",
    "fig.append_trace(left_spikes, 1, 1)\n",
    "right_spikes = go.Scattergl(x=[],\n",
    "                          y=[],\n",
    "                          marker={'symbol': 'line-ns', 'line': {'width': 1, 'color':'#ff7f03'},\n",
    "                                  'color':'#ff7f03'},\n",
    "                          mode='markers',\n",
    "                          name='right motoneuron',\n",
    "                          showlegend=False)\n",
    "fig.append_trace(right_spikes, 1, 1)\n",
    "\n",
    "eye_position = go.Scattergl(x=[],\n",
    "                          y=[],\n",
    "                          mode='lines',\n",
    "                          line={'color': 'black'},\n",
    "                          name='eye')\n",
    "fig.append_trace(eye_position, 3, 1)\n",
    "object_position = go.Scattergl(x=[],\n",
    "                             y=[],\n",
    "                             mode='lines',\n",
    "                             line={'color': '#2ca02c'},\n",
    "                             name='object')\n",
    "fig.append_trace(object_position, 3, 1)\n",
    "\n",
    "fig['layout'].update(xaxis1={'showline': False,\n",
    "                             'zeroline': False,\n",
    "                             'title': 'time (in s)',\n",
    "                             'range': (0, 10),\n",
    "                             'ticktext': ['-10', '-8', '-6', '-4', '-2', '0'],\n",
    "                             'tickvals': [0, 2, 4, 6, 8, 10]},\n",
    "                     yaxis1={'title': 'neuron index',\n",
    "                             'showticklabels': False,\n",
    "                             'showline': True,\n",
    "                             'range': (0, N+2)},\n",
    "                     yaxis2={'tickmode': 'array',\n",
    "                             'ticktext': ['left', 'right'],\n",
    "                             'tickvals': [-1, 1],\n",
    "                             'range': [-1.05, 1.05],\n",
    "                             'zeroline': True,\n",
    "                             'showline': True}\n",
    "                     )\n",
    "fig_widget = go.FigureWidget(fig)\n",
    "retina_spikes, left_spikes, right_spikes, eye_position, object_position = fig_widget.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create interactive widgets that the user can use to start/stop the simulation, as well as for setting certain simulation parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_label = widgets.Label(value='Time: 0 s')\n",
    "start_stop_button = widgets.Button(tooltip='Start simulation', icon='play')\n",
    "\n",
    "tau_obj_slider = widgets.FloatSlider(orientation='horizontal', description='tau_object',\n",
    "                                     value=500, min=100, max=1000)\n",
    "tau_muscle_slider = widgets.FloatSlider(orientation='horizontal', description='tau_muscle',\n",
    "                                        value=20, min=5, max=100)\n",
    "weight_slider = widgets.FloatSlider(orientation='horizontal', description='w_muscle',\n",
    "                                    value=0.5, min=0, max=2)\n",
    "sliders = widgets.VBox([widgets.HBox([time_label, start_stop_button]),\n",
    "                        tau_obj_slider, tau_muscle_slider, weight_slider])\n",
    "layout = widgets.HBox([fig_widget, sliders])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We interact with the running simulation via a \"network operation\", a Python function that will be regularly called by Brian during the simulation run (here, every 100ms of biological time). This function can access arbitrary attributes of the model to get or set their values. We use this here to 1) update the plot with the data from the last second and 2) set parameters of the model to the values requested by the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "should_stop = False\n",
    "@network_operation(dt=500*ms)\n",
    "def plot_output(t):\n",
    "    with fig_widget.batch_update():\n",
    "        cutoff = (t - 10*second)\n",
    "        # Plot the data of the last 10 seconds\n",
    "        indices = S_retina.t > cutoff\n",
    "        retina_spikes.x = (S_retina.t[indices] - cutoff)/second\n",
    "        retina_spikes.y = S_retina.i[indices]\n",
    "        motoneuron_trains = S_motoneurons.spike_trains()\n",
    "        to_plot = motoneuron_trains[0][motoneuron_trains[0] > cutoff]\n",
    "        left_spikes.x = (to_plot - cutoff)/second\n",
    "        left_spikes.y = np.ones(len(to_plot))*N\n",
    "        to_plot = motoneuron_trains[1][motoneuron_trains[1] > cutoff]\n",
    "        right_spikes.x = (to_plot - cutoff)/second\n",
    "        right_spikes.y = np.ones(len(to_plot))*(N+1)\n",
    "        indices = M.t > cutoff\n",
    "        eye_position.x = (M.t[indices] - cutoff)/second\n",
    "        eye_position.y = M.x[0][indices]\n",
    "        object_position.x = (M.t[indices] - cutoff)/second\n",
    "        object_position.y = M.x_object[0][indices]\n",
    "    time_label.value = 'Time: {:.1f}s'.format(float(t[:]))\n",
    "    # Set the simulation parameters according to user settings\n",
    "    eye.tau_object = tau_obj_slider.value*ms\n",
    "    eye.tau_muscle = tau_muscle_slider.value*ms\n",
    "    motosynapses.w = [-weight_slider.value, weight_slider.value]\n",
    "    if should_stop:\n",
    "        net.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We store the model and the \"network operation\" in a `Network` object, and store its current state to allow for repeated execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = Network(collect())\n",
    "net.store()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now define two helper functions used to start/stop simulations. The actual simulation will be run in a background thread so that the user interface stays reactive while the simulation is running:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_run(runtime):\n",
    "    net.restore()\n",
    "    net.run(runtime)\n",
    "running = False\n",
    "def button_pressed(b):\n",
    "    global running\n",
    "    global should_stop\n",
    "    if running:\n",
    "        should_stop = True\n",
    "        running = False\n",
    "        start_stop_button.tooltip = 'Start simulation'\n",
    "        start_stop_button.icon = 'play'\n",
    "    else:\n",
    "        should_stop = False\n",
    "        running = True\n",
    "        time_label.value = 'starting...'\n",
    "        start_stop_button.tooltip = 'Stop simulation'\n",
    "        start_stop_button.icon = 'stop'\n",
    "        thread = threading.Thread(target=do_run, args=(100*second, ))\n",
    "        thread.start()\n",
    "start_stop_button.on_click(button_pressed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now ready to display the plot and user interface, which can then be used to start the simulation and interact with the simulation parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(layout)"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}