grouper-prototype.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Exploration Dash Prototype "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Imports\n",
    "#\n",
    "\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go\n",
    "from jupyter_dash import JupyterDash\n",
    "from dash import callback_context\n",
    "import dash_core_components as dcc\n",
    "import dash_html_components as html\n",
    "from dash.dependencies import Input, Output, State\n",
    "import pandas as pd\n",
    "import os, ntpath\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "import numpy as np\n",
    "import gillespy2\n",
    "from gillespy2 import Model, Species, Reaction, Parameter, RateRule, AssignmentRule, FunctionDefinition\n",
    "from gillespy2 import EventAssignment, EventTrigger, Event"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "## GillesPy2 Model\n",
    "#\n",
    "\n",
    "class Dimerization(Model):\n",
    "    def __init__(self, parameter_values=None):\n",
    "        Model.__init__(self, name=\"Dimerization\")\n",
    "        self.volume = 1\n",
    "\n",
    "        # Parameters\n",
    "        self.add_parameter(Parameter(name=\"k_c\", expression=0.005))\n",
    "        self.add_parameter(Parameter(name=\"k_d\", expression=0.08))\n",
    "\n",
    "        # Species\n",
    "        self.add_species(Species(name=\"Monomer\", initial_value=30, mode=\"discrete\"))\n",
    "        self.add_species(Species(name=\"Dimer\", initial_value=0, mode=\"discrete\"))\n",
    "\n",
    "        # Reactions\n",
    "        self.add_reaction(Reaction(name=\"r_creation\", reactants={'Monomer': 2}, products={'Dimer': 1}, rate=self.listOfParameters[\"k_c\"]))\n",
    "        self.add_reaction(Reaction(name=\"r_dissociation\", reactants={'Dimer': 1}, products={'Monomer': 2}, rate=self.listOfParameters[\"k_d\"]))\n",
    "\n",
    "        # Timespan\n",
    "        self.timespan(np.linspace(0, 100, 101))\n",
    "        \n",
    "model = Dimerization()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sciope.utilities.gillespy2 import wrapper\n",
    "settings = {\"number_of_trajectories\":1}\n",
    "simulator = wrapper.get_simulator(gillespy_model=model, run_settings=settings, species_of_interest=['Monomer', 'Dimer'])\n",
    "expression_array = wrapper.get_parameter_expression_array(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dask.distributed import Client\n",
    "from sciope.designs import latin_hypercube_sampling\n",
    "from sciope.utilities.summarystats.auto_tsfresh import SummariesTSFRESH\n",
    "\n",
    "c = Client()\n",
    "lhc = latin_hypercube_sampling.LatinHypercube(xmin=expression_array, xmax=expression_array*3)\n",
    "lhc.generate_array(1000) #creates a LHD of size 1000\n",
    "\n",
    "#will use default minimal set of features\n",
    "summary_stats = SummariesTSFRESH()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mgeiger/.pyenv/versions/3.8.2/envs/dash-playtest/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning:\n",
      "\n",
      "The sklearn.manifold.t_sne module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.manifold. Anything that cannot be imported from sklearn.manifold is now part of the private API.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sciope.stochmet.stochmet import StochMET\n",
    "\n",
    "met = StochMET(simulator, lhc, summary_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "met.compute(n_points=50, chunk_size=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#First lets add some appropiate information about the model and features\n",
    "met.data.configurations['listOfParameters'] = list(model.listOfParameters.keys())\n",
    "met.data.configurations['listOfSpecies'] = list(model.listOfSpecies.keys())\n",
    "met.data.configurations['listOfSummaries'] = met.summaries.features\n",
    "met.data.configurations['timepoints'] = model.tspan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Start of Dash Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Defaults\n",
    "#\n",
    "\n",
    "default_num_groups = 5\n",
    "default_trajectory_selector = 'slider' # either 'dropdown' or 'slider'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Helpers\n",
    "#\n",
    "\n",
    "def options_factory(iterable, label_accessor=lambda x: x, value_accessor=lambda x: x):\n",
    "    \"\"\"\n",
    "    Factory function for creating a dash dropdown menu's 'options' attribute.\n",
    "\n",
    "    Positional arguments:\n",
    "    iterable -- any iterable data structure.\n",
    "\n",
    "    Keyword arguments (optional):\n",
    "    label_accessor -- function to retrieve the label from a single data point in iterable.\n",
    "    value_accessor -- function to retrieve the value from a single data point in iterable.\n",
    "\n",
    "    Returns a list of dictionaries with keys 'label' and 'value'.\n",
    "    \"\"\"\n",
    "    return [\n",
    "        { 'label': label_accessor(d), 'value': value_accessor(d) }\n",
    "        for d in iterable\n",
    "    ]\n",
    "\n",
    "\n",
    "def read_ensemble_data_from_results_folder(folder):\n",
    "    \"\"\"\n",
    "    Read GillesPy2 ensemble simulation results into a list of pandas data frames.\n",
    "    \n",
    "    Positional arguments:\n",
    "    folder -- folder on disk containing csv files with one trajectory result per file.\n",
    "    \n",
    "    Returns:\n",
    "    List of pandas DataFrame objects where the index represents the trajectory number and \n",
    "    values are 2-dimensional arrays where columns are species and rows are \n",
    "    result values for each species at some time step.\n",
    "    \"\"\"\n",
    "    files = sorted([ os.path.join(results_dir, f) for f in os.listdir(results_dir) ])\n",
    "    dfs = [ pd.read_csv(f_path) for f_path in files ]\n",
    "    return dfs\n",
    "\n",
    "\n",
    "def get_zeroed_df(df):\n",
    "    zero_df = df - df\n",
    "    zero_df['time'] = df['time'].copy()\n",
    "    return zero_df\n",
    "\n",
    "\n",
    "def compute_dfs_mean(dataframes):\n",
    "    \"\"\"\n",
    "    Compute the mean dataframe of a list of pandas dataframes.\n",
    "    \"\"\"\n",
    "    if len(dataframes):\n",
    "        # Using overloaded pandas DataFrame operators\n",
    "        sum = reduce(lambda df1, df2: df1 + df2, dataframes)\n",
    "        mean = sum / len(dataframes)\n",
    "        return mean.to_json(orient='split')\n",
    "    else:\n",
    "        # Empty Group\n",
    "        return get_zeroed_df(dfs[0]).to_json(orient='split')\n",
    "\n",
    "\n",
    "def get_group_trajectories(group, group_assigns):\n",
    "    \"\"\"\n",
    "    Given a group index and list of group assignments,\n",
    "    return a list of trajectory indices belonging to that group.\n",
    "    \n",
    "    group -- group number (0-indexed)\n",
    "    group_assigns -- a list where an index is a trajectory id and a value is\n",
    "                     the group the trajectory is assigned to.\n",
    "    \"\"\"\n",
    "    return [ i for i in range(len(group_assigns)) if group_assigns[i] == group ]\n",
    "\n",
    "\n",
    "def compute_group_data(group_data, group_assigns, dfs):\n",
    "    \"\"\"\n",
    "    Compute all group metrics based on current group assignments\n",
    "    \"\"\"\n",
    "    # if group has no data and now has data, we'll need to make a new data frame\n",
    "    dfs = [ pd.read_json(df, orient='split') for df in dfs ]\n",
    "    for group in range(len(group_data)):\n",
    "        group_trjs = get_group_trajectories(group, group_assigns)\n",
    "        group_dfs = [ dfs[i] for i in range(len(dfs)) if i in group_trjs ]\n",
    "        group_data[group] = compute_dfs_mean(group_dfs)\n",
    "    return group_data\n",
    "\n",
    "\n",
    "def default_local_store(dfs, num_groups):\n",
    "    \"\"\"\n",
    "    Initial client-side JSON storage for callbacks to refernece.\n",
    "    \"\"\"\n",
    "    return {\n",
    "        'dfs': [ df.to_json(orient='split') for df in dfs ],\n",
    "        'group_assigns' : [None] * len(dfs),\n",
    "        'group_data' : [get_zeroed_df(dfs[0]).to_json(orient='split')] * default_num_groups\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Read the data\n",
    "#\n",
    "\n",
    "results_dir = './results_csv_06042020_150109/'\n",
    "dfs = read_ensemble_data_from_results_folder(results_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Setup menus and styling for dropdowns\n",
    "#\n",
    "\n",
    "# Extra styling for dropdowns\n",
    "dropdown_styles = {\n",
    "}\n",
    "\n",
    "# Setup species dropdown options\n",
    "all_species = [ c for c in dfs[0].columns if c != 'time' ]\n",
    "species_options = options_factory(all_species)\n",
    "species_options.insert(0, options_factory(['All'])[0])\n",
    "\n",
    "# Group dropdown options\n",
    "group_options = options_factory(\n",
    "    # 0-indexed internally, labeled as 1-indexed\n",
    "    range(default_num_groups), label_accessor=lambda x: str(x+1)\n",
    ")\n",
    "\n",
    "# Trajectory dropdown options\n",
    "trajectory_options = options_factory(\n",
    "    # 0-indexed internally, labeled as 1-indexed\n",
    "    range(len(dfs)), label_accessor=lambda x: str(x+1)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## App\n",
    "#\n",
    "\n",
    "external_stylesheets = [\n",
    "    {\n",
    "        'href': 'https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css',\n",
    "        'rel': 'stylesheet',\n",
    "        'integrity': 'sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO',\n",
    "        'crossorigin': 'anonymous'\n",
    "    }\n",
    "]\n",
    "\n",
    "app = JupyterDash(__name__, external_stylesheets=external_stylesheets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Fragments\n",
    "#\n",
    "\n",
    "# Initial client JSON store\n",
    "store = default_local_store(dfs, default_num_groups)\n",
    "\n",
    "# Trajectory selector (dropdown)\n",
    "trajectory_selector_dropdown = html.Label([\n",
    "    dcc.Dropdown(style=dropdown_styles,\n",
    "        id='trajectory-selector', clearable=False,\n",
    "        options=trajectory_options, value=0)\n",
    "])\n",
    "\n",
    "# Trajectory selector (slider)\n",
    "trajectory_selector_slider = html.Div([\n",
    "    dcc.Slider(\n",
    "        id='trajectory-selector',\n",
    "        min=0,\n",
    "        max=len(trajectory_options)-1,\n",
    "        step=1,\n",
    "        value=0,\n",
    "        marks = { d['value']:d['label'] for d in trajectory_options }\n",
    "    ),\n",
    "    html.Div(id='slider-output-container')\n",
    "])\n",
    "\n",
    "# Get default trajectory selector (slider or dropdown, determined from config above)\n",
    "default_trajectory_selector = trajectory_selector_dropdown if default_trajectory_selector == 'dropdown' else trajectory_selector_slider"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Components\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Group Assigner layout\n",
    "group_assigner_layout = html.Div([\n",
    "    html.Div([\n",
    "        html.H4(children=\"Assign Ensemble Trajectories to Groups\")\n",
    "    ], className='col-md-12'),\n",
    "    html.Div([\n",
    "        html.Label(\"Trajectory\"),\n",
    "        html.Div(children=default_trajectory_selector, id='trajectory-selector-container'),\n",
    "        html.Button('Dropdown', id='select-trajectory-dropdown-btn', n_clicks=0),\n",
    "        html.Button('Slider', id='select-trajectory-slider-btn', n_clicks=0)\n",
    "        ],\n",
    "        id='trajectory-selector-wrapper',\n",
    "        className='col-md-12'\n",
    "    ),\n",
    "    html.Div([\n",
    "        html.Label(\"Show Species\"),\n",
    "        dcc.Dropdown(\n",
    "                id='species-dropdown-trajectory',\n",
    "                style=dropdown_styles,\n",
    "                clearable=False,\n",
    "                value='All',\n",
    "                options=species_options\n",
    "        )\n",
    "        ],\n",
    "        id='group-assigner-select-species-wrapper',\n",
    "        className='col-md-6'\n",
    "    ),\n",
    "    html.Div([\n",
    "        html.Label(\"Assign to Group\"),\n",
    "        dcc.Dropdown(id='group-assigner-group-select-dropdown', clearable=True, style=dropdown_styles, options=group_options, value=0)\n",
    "        ],\n",
    "        id='group-assigner-dropdown-wrapper',\n",
    "        className='col-md-6'\n",
    "    ),\n",
    "    html.Div([\n",
    "        html.Div([\n",
    "            html.Button('Toggle Graph Display', id='toggle-trajectory-graph-btn', n_clicks=0,\n",
    "            style={ 'padding': '5px', 'margin-top': '10px' }),\n",
    "        ]\n",
    "        ),\n",
    "        html.Div([ dcc.Graph(id='group-assigner-graph') ],\n",
    "                 id='group-assigner-graph-wrapper',\n",
    "                 className='col-md-6',\n",
    "        ),\n",
    "        ],\n",
    "        id='group-assigner-graph-and-tgl-btn-wrapper',\n",
    "        className='col-md-12'\n",
    "    )\n",
    "], className='card card-body')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Group assigner callbacks\n",
    "\n",
    "# Update the trajectory graph\n",
    "@app.callback(\n",
    "    Output('group-assigner-graph', 'figure'),\n",
    "    [Input('species-dropdown-trajectory', 'value'),\n",
    "     Input('trajectory-selector', 'value')]\n",
    ")\n",
    "def update_group_assignment_graph(species, trajectory):\n",
    "    if species == 'All':\n",
    "        species = all_species\n",
    "    return px.line(\n",
    "        dfs[trajectory], x=\"time\", y=species,\n",
    "        render_mode=\"webgl\", title=\"Trajectory {}\".format(trajectory+1)\n",
    "    )\n",
    "\n",
    "\n",
    "# Toggle the trajectory graph display\n",
    "@app.callback(\n",
    "    Output('group-assigner-graph', 'style'),\n",
    "    [Input('toggle-trajectory-graph-btn', 'n_clicks')],\n",
    ")\n",
    "def toggle_group_assignment_graph(n_clicks):\n",
    "    changed_id = [p['prop_id'] for p in callback_context.triggered][0]\n",
    "    if 'toggle-trajectory-graph-btn' in changed_id and n_clicks:\n",
    "        return { 'display' : 'none' } if n_clicks % 2 else {}\n",
    "    return {}\n",
    "\n",
    "\n",
    "# Switch trajectory selector interface (slider or dropdown)\n",
    "@app.callback(\n",
    "    Output('trajectory-selector-container', 'children'),\n",
    "    [Input('select-trajectory-dropdown-btn', 'n_clicks'),\n",
    "     Input('select-trajectory-slider-btn', 'n_clicks')],\n",
    "    [State('trajectory-selector-container', 'children')]\n",
    ")\n",
    "def update_trajectory_selector_dropdown(dropdown_n_clicks, slider_n_clicks, current):\n",
    "    changed_id = [p['prop_id'] for p in callback_context.triggered][0]\n",
    "    if 'select-trajectory-dropdown-btn' in changed_id and dropdown_n_clicks:\n",
    "        return trajectory_selector_dropdown\n",
    "    if 'select-trajectory-slider-btn' in changed_id and slider_n_clicks:\n",
    "        return trajectory_selector_slider\n",
    "    return current\n",
    "\n",
    "\n",
    "# Update the 'set group' dropdown when selected trajectory changes\n",
    "@app.callback(\n",
    "    Output('group-assigner-group-select-dropdown', 'value'),\n",
    "    [Input('memory', 'modified_timestamp'),\n",
    "     Input('trajectory-selector', 'value')],\n",
    "    [State('memory', 'data')]\n",
    ")\n",
    "def update_group_dropdown(timestamp, trajectory, memory):\n",
    "    return memory['group_assigns'][trajectory]\n",
    "\n",
    "\n",
    "# Store the trajectory's group when the user selects from the group dropdown\n",
    "# Recompute group metrics and update group data\n",
    "# TODO the group dropdown changes when the trajectory is changed too\n",
    "#      is this a memory input?\n",
    "@app.callback(\n",
    "    Output('memory', 'data'),\n",
    "    [Input('group-assigner-group-select-dropdown', 'value')],\n",
    "    [State('trajectory-selector', 'value'),\n",
    "     State('memory', 'data')]\n",
    ")\n",
    "def update_trajectory_group(selected_group, trajectory, memory):\n",
    "    from_group = memory['group_assigns'][trajectory]\n",
    "    memory['group_assigns'][trajectory] = selected_group\n",
    "    if from_group != selected_group:\n",
    "        memory['group_data'] = compute_group_data(memory['group_data'], memory['group_assigns'], memory['dfs'])\n",
    "    return memory\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Group inspector layout\n",
    "group_inspector_layout = html.Div([\n",
    "    html.H4(children=\"Group Inspector\"),\n",
    "    html.Label([\n",
    "    \"Select Group\",\n",
    "    dcc.Dropdown(id='group-inspector-select-group-dropdown', clearable=True, style=dropdown_styles, options=group_options, value=0)\n",
    "    ]),\n",
    "    html.Label([\n",
    "    \"Show Species\",\n",
    "    dcc.Dropdown(style=dropdown_styles,\n",
    "        id='group-inspector-species-dropdown', clearable=False,\n",
    "        value='All', options=species_options)\n",
    "    ]),\n",
    "    dcc.Graph(id='group-inspect-graph')\n",
    "], className='card card-body')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Group inspector callbacks\n",
    "\n",
    "# Update the group inspector graph\n",
    "@app.callback(\n",
    "    Output('group-inspect-graph', 'figure'),\n",
    "    [Input('group-inspector-select-group-dropdown', 'value'),\n",
    "     Input('group-inspector-species-dropdown', 'value'),\n",
    "     Input('memory', 'data')]\n",
    ")\n",
    "def update_group_inspector_graph(group, species, memory):\n",
    "    if species == 'All':\n",
    "        species = all_species\n",
    "    try:\n",
    "        return px.line(pd.read_json(memory['group_data'][group], orient='split'),\n",
    "                       x='time', y=species, render_mode='webgl',\n",
    "                       title='Group {}'.format(group+1)\n",
    "                      )\n",
    "    except:\n",
    "        return px.line()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "## App Layout\n",
    "#\n",
    "\n",
    "app.layout = html.Div([\n",
    "    dcc.Store(id='memory', data=store),\n",
    "    group_assigner_layout,\n",
    "    group_inspector_layout\n",
    "],\n",
    "style={\n",
    "    'font-family': 'Arial, Helvetica, sans-serif'\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Run\n",
    "#\n",
    "\n",
    "app.run_server(mode='jupyterlab', debug=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}