docs/notebooks/NewTask.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# THIS CELL SETS STUFF UP FOR DEMO / COLLAB. THIS CELL CAN BE IGNORED.\n",
    "\n",
    "#-------------------------------------GET RID OF TF DEPRECATION WARNINGS--------------------------------------#\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore', category=FutureWarning)\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)\n",
    "\n",
    "#----------------------------------INSTALL PSYCHRNN IF IN A COLAB NOTEBOOK-------------------------------------#\n",
    "# Installs the correct branch / release version based on the URL. If no branch is provided, loads from master.\n",
    "try:\n",
    "  import google.colab\n",
    "  IN_COLAB = True\n",
    "except:\n",
    "  IN_COLAB = False\n",
    "\n",
    "if IN_COLAB:\n",
    "    import json\n",
    "    import re\n",
    "    import ipykernel\n",
    "    import requests \n",
    "    from requests.compat import urljoin\n",
    "\n",
    "    from notebook.notebookapp import list_running_servers\n",
    "    kernel_id = re.search('kernel-(.*).json',\n",
    "                          ipykernel.connect.get_connection_file()).group(1)\n",
    "    servers = list_running_servers()\n",
    "    for ss in servers:\n",
    "        response = requests.get(urljoin(ss['url'], 'api/sessions'),\n",
    "                                params={'token': ss.get('token', '')})\n",
    "        for nn in json.loads(response.text):\n",
    "            if nn['kernel']['id'] == kernel_id:\n",
    "                relative_path = nn['notebook']['path'].split('%2F')\n",
    "                if 'blob' in relative_path:\n",
    "                  blob = relative_path[relative_path.index('blob') + 1]\n",
    "                  !pip install git+https://github.com/murraylab/PsychRNN@$blob\n",
    "                else:\n",
    "                  !pip install git+https://github.com/murraylab/PsychRNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define New Task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a sample implentation of a simple perceptual discrimination task. The newly defined task implements and inherits from [Task](../apidoc/tasks.rst#module-psychrnn.tasks.task). Other examples of tasks are available [here](../apidoc/tasks.rst#implemented-example-tasks).\n",
    "\n",
    "This task will involve two inputs and two outputs. The network must indicate which of the two inputs (directions) has larger signal, and the mean difference in magnitude of the two inputs will be indicated by coherence.\n",
    "\n",
    "To define the task, ``generate_trial_params`` and ``trial_function`` are the two key functions that must be defined. \n",
    "\n",
    "In this simple task, ``generate_trial_params`` assigns both the direction and the coherence of the trial randomly.\n",
    "\n",
    "``trial_function`` is given a time point indicating what time in the trial it is currently at as well as the output from ``generate_trial_params``. The function intializes the input, ``x_t``, with noise, the output, ``y_t``, with zeros, and the mask, ``mask_t`` with ones. During the stimulus period, ``x_t`` has input signal added to it. During the response period, ``y_t[direction]`` is set to 1 to indicate the correct direction of the stimulus. Before and during the stimlus period, the mask is set to 0 so that when training, the network knows not to care about it's outputs before the response period.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from psychrnn.tasks.task import Task\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "class SimplePD(Task):\n",
    "    def __init__(self, dt, tau, T, N_batch):\n",
    "        super(SimplePDM, self).__init__(2, 2, dt, tau, T, N_batch)\n",
    "\n",
    "    def generate_trial_params(self, batch, trial):\n",
    "        \"\"\"\"Define parameters for each trial.\n",
    "\n",
    "        Using a combination of randomness, presets, and task attributes, define the necessary trial parameters.\n",
    "\n",
    "        Args:\n",
    "            batch (int): The batch number that this trial is part of.\n",
    "            trial (int): The trial number of the trial within the batch.\n",
    "\n",
    "        Returns:\n",
    "            dict: Dictionary of trial parameters.\n",
    "            \n",
    "        \"\"\"\n",
    "\n",
    "        # ----------------------------------\n",
    "        # Define parameters of a trial\n",
    "        # ----------------------------------\n",
    "        params = dict()\n",
    "        params['coherence'] = np.random.exponential(scale=1/5)\n",
    "        params['direction'] = np.random.choice([0, 1])\n",
    "\n",
    "        return params\n",
    "\n",
    "    def trial_function(self, time, params):\n",
    "        \"\"\" Compute the trial properties at the given time.\n",
    "\n",
    "        Based on the params compute the trial stimulus (x_t), correct output (y_t), and mask (mask_t) at the given time.\n",
    "\n",
    "        Args:\n",
    "            time (int): The time within the trial (0 <= time < T).\n",
    "            params (dict): The trial params produced generate_trial_params()\n",
    "\n",
    "        Returns:\n",
    "            tuple:\n",
    "\n",
    "            x_t (ndarray(dtype=float, shape=(N_in,))): Trial input at time given params.\n",
    "            y_t (ndarray(dtype=float, shape=(N_out,))): Correct trial output at time given params.\n",
    "            mask_t (ndarray(dtype=bool, shape=(N_out,))): True if the network should train to match the y_t, False if the network should ignore y_t when training.\n",
    "        \n",
    "        \"\"\"\n",
    "        stim_noise = 0.1\n",
    "        onset = self.T/4.0\n",
    "        stim_dur = self.T/2.0\n",
    "\n",
    "        # ----------------------------------\n",
    "        # Initialize with noise\n",
    "        # ----------------------------------\n",
    "        x_t = np.sqrt(2*self.alpha*stim_noise*stim_noise)*np.random.randn(self.N_in)\n",
    "        y_t = np.zeros(self.N_out)\n",
    "        mask_t = np.ones(self.N_out)\n",
    "\n",
    "        # ----------------------------------\n",
    "        # Retrieve parameters\n",
    "        # ----------------------------------\n",
    "        coh = params['coherence']\n",
    "        direction = params['direction']\n",
    "\n",
    "        # ----------------------------------\n",
    "        # Compute values\n",
    "        # ----------------------------------\n",
    "        if onset < time < onset + stim_dur:\n",
    "            x_t[direction] += 1 + coh\n",
    "            x_t[(direction + 1) % 2] += 1\n",
    "\n",
    "        if time > onset + stim_dur + 20:\n",
    "            y_t[direction] = 1.\n",
    "\n",
    "        if time < onset + stim_dur:\n",
    "            mask_t = np.zeros(self.N_out)\n",
    "\n",
    "        return x_t, y_t, mask_t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that the task is defined, we can instantiate it and use it to build a model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 1280, Minibatch Loss= 0.103770\n",
      "Iter 2560, Minibatch Loss= 0.069724\n",
      "Iter 3840, Minibatch Loss= 0.062085\n",
      "Iter 5120, Minibatch Loss= 0.059507\n",
      "Iter 6400, Minibatch Loss= 0.055375\n",
      "Iter 7680, Minibatch Loss= 0.049892\n",
      "Iter 8960, Minibatch Loss= 0.037656\n",
      "Iter 10240, Minibatch Loss= 0.023892\n",
      "Iter 11520, Minibatch Loss= 0.015843\n",
      "Iter 12800, Minibatch Loss= 0.012522\n",
      "Iter 14080, Minibatch Loss= 0.011632\n",
      "Iter 15360, Minibatch Loss= 0.013904\n",
      "Iter 16640, Minibatch Loss= 0.011842\n",
      "Iter 17920, Minibatch Loss= 0.009156\n",
      "Iter 19200, Minibatch Loss= 0.009582\n",
      "Iter 20480, Minibatch Loss= 0.009885\n",
      "Iter 21760, Minibatch Loss= 0.007577\n",
      "Iter 23040, Minibatch Loss= 0.009727\n",
      "Iter 24320, Minibatch Loss= 0.005300\n",
      "Iter 25600, Minibatch Loss= 0.008526\n",
      "Iter 26880, Minibatch Loss= 0.009385\n",
      "Iter 28160, Minibatch Loss= 0.008682\n",
      "Iter 29440, Minibatch Loss= 0.005043\n",
      "Iter 30720, Minibatch Loss= 0.010335\n",
      "Iter 32000, Minibatch Loss= 0.005916\n",
      "Iter 33280, Minibatch Loss= 0.007762\n",
      "Iter 34560, Minibatch Loss= 0.007408\n",
      "Iter 35840, Minibatch Loss= 0.005352\n",
      "Iter 37120, Minibatch Loss= 0.005865\n",
      "Iter 38400, Minibatch Loss= 0.010364\n",
      "Iter 39680, Minibatch Loss= 0.007844\n",
      "Iter 40960, Minibatch Loss= 0.006617\n",
      "Iter 42240, Minibatch Loss= 0.004358\n",
      "Iter 43520, Minibatch Loss= 0.005139\n",
      "Iter 44800, Minibatch Loss= 0.006852\n",
      "Iter 46080, Minibatch Loss= 0.006175\n",
      "Iter 47360, Minibatch Loss= 0.006748\n",
      "Iter 48640, Minibatch Loss= 0.006968\n",
      "Iter 49920, Minibatch Loss= 0.006449\n",
      "Optimization finished!\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from psychrnn.backend.models.basic import Basic\n",
    "\n",
    "# ---------------------- Set up a basic model ---------------------------\n",
    "pd = SimplePD(dt = 10, tau = 100, T = 2000, N_batch = 128)\n",
    "network_params = pd.get_task_params() # get the params passed in and defined in pd\n",
    "network_params['name'] = 'model' # name the model uniquely if running mult models in unison\n",
    "network_params['N_rec'] = 50 # set the number of recurrent units in the model\n",
    "model = Basic(network_params) # instantiate a basic vanilla RNN\n",
    "\n",
    "# ---------------------- Train a basic model ---------------------------\n",
    "model.train(pd) # train model to perform pd task\n",
    "\n",
    "# ---------------------- Test the trained model ---------------------------\n",
    "x,target_output,mask, trial_params = pd.get_trial_batch() # get pd task inputs and outputs\n",
    "model_output, model_state = model.test(x) # run the model on input x\n",
    "\n",
    "# ---------------------- Plot the results ---------------------------\n",
    "plt.plot(model_output[0][0,:,:])\n",
    "\n",
    "# ---------------------- Teardown the model -------------------------\n",
    "model.destruct()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}