NeuronModel/RasterizedVis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import glob\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools as it\n",
    "import matplotlib.cm as cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "SimPath = '/Users/sahand/Research/NeuroNet/Data/07-31-2017/Sim2_N5120_L1000_S10_D400_T60000'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fixing Storage Path in Parameters File "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def FixPathsParallel(datafolder=\"/Users/sahand/Research/NeuroNet/Data/Sim5_0626201\"):\n",
    "    folders = os.listdir(datafolder)\n",
    "    visfolder = datafolder+\"/\"+\"Vis\"\n",
    "    if not os.path.exists(visfolder):\n",
    "        os.makedirs(visfolder)\n",
    "    with open(datafolder+\"/Parameters.json\", 'r') as file:\n",
    "        data = json.load(file)\n",
    "        data[\"DataFolder\"]=datafolder\n",
    "    with open(datafolder+\"/Parameters.json\", 'w') as file:\n",
    "        json.dump(data, file, indent=4, separators=(',', ': '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "FixPathsParallel(datafolder=SimPath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulation Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class DictTable(dict):\n",
    "    # Overridden dict class which takes a dict in the form {'a': 2, 'b': 3},\n",
    "    # and renders an HTML Table in IPython Notebook.\n",
    "    def _repr_html_(self):\n",
    "        html = ['<table align=\"left\" width=100%>']\n",
    "        html.append('<tr>')\n",
    "        html.append('<th align=\"left\">Paramater Name</th>')\n",
    "        html.append('<th align=\"left\">Paramater Value</th>')\n",
    "        html.append(\"<tr>\")\n",
    "        for key, value in iter(self.items()):\n",
    "            html.append(\"<tr>\")\n",
    "            html.append(\"<td>{0}</td>\".format(str(key)))\n",
    "            html.append(\"<td>{0}</td>\".format(str(value)))\n",
    "            html.append(\"</tr>\")\n",
    "        html.append(\"</table>\")\n",
    "        return ''.join(html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open(SimPath+\"/Parameters.json\") as data_file:\n",
    "    metadata = json.load(data_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table align=\"left\" width=100%><tr><th align=\"left\">Paramater Name</th><th align=\"left\">Paramater Value</th><tr><tr><td>C</td><td>20</td></tr><tr><td>C_v</td><td>1</td></tr><tr><td>ConnectionScale</td><td>10</td></tr><tr><td>DataFolder</td><td>/Users/sahand/Research/NeuroNet/Data/07-31-2017/Sim2_N5120_L1000_S10_D400_T60000</td></tr><tr><td>I</td><td>0</td></tr><tr><td>I_v</td><td>0.1</td></tr><tr><td>JobID</td><td>7258744.bw</td></tr><tr><td>NetworkDevel</td><td>400</td></tr><tr><td>NeuronsPerFile</td><td>200</td></tr><tr><td>NumberOfFiles</td><td>26</td></tr><tr><td>NumberOfNeurons</td><td>5120</td></tr><tr><td>SynapseLimit</td><td>1000</td></tr><tr><td>V1</td><td>-1.2</td></tr><tr><td>V1_v</td><td>0.01</td></tr><tr><td>V2</td><td>18.0</td></tr><tr><td>V2_v</td><td>0.01</td></tr><tr><td>V3</td><td>2.0</td></tr><tr><td>V3_v</td><td>0.01</td></tr><tr><td>V4</td><td>30.0</td></tr><tr><td>V4_v</td><td>0.01</td></tr><tr><td>VCa</td><td>120</td></tr><tr><td>VCa_v</td><td>0.01</td></tr><tr><td>VK</td><td>-84</td></tr><tr><td>VK_v</td><td>0.01</td></tr><tr><td>VL</td><td>-60</td></tr><tr><td>VL_v</td><td>0.01</td></tr><tr><td>dt</td><td>0.1</td></tr><tr><td>gCa</td><td>4.4</td></tr><tr><td>gCa_v</td><td>0.01</td></tr><tr><td>gK</td><td>8</td></tr><tr><td>gK_v</td><td>0.01</td></tr><tr><td>gL</td><td>2.0</td></tr><tr><td>gL_v</td><td>0.01</td></tr><tr><td>phi</td><td>0.04</td></tr><tr><td>phi_v</td><td>0.01</td></tr><tr><td>tend</td><td>60000</td></tr></table>"
      ],
      "text/plain": [
       "{'C': 20,\n",
       " 'C_v': 1,\n",
       " 'ConnectionScale': 10,\n",
       " 'DataFolder': '/Users/sahand/Research/NeuroNet/Data/07-31-2017/Sim2_N5120_L1000_S10_D400_T60000',\n",
       " 'I': 0,\n",
       " 'I_v': 0.1,\n",
       " 'JobID': '7258744.bw',\n",
       " 'NetworkDevel': 400,\n",
       " 'NeuronsPerFile': 200,\n",
       " 'NumberOfFiles': 26,\n",
       " 'NumberOfNeurons': 5120,\n",
       " 'SynapseLimit': 1000,\n",
       " 'V1': -1.2,\n",
       " 'V1_v': 0.01,\n",
       " 'V2': 18.0,\n",
       " 'V2_v': 0.01,\n",
       " 'V3': 2.0,\n",
       " 'V3_v': 0.01,\n",
       " 'V4': 30.0,\n",
       " 'V4_v': 0.01,\n",
       " 'VCa': 120,\n",
       " 'VCa_v': 0.01,\n",
       " 'VK': -84,\n",
       " 'VK_v': 0.01,\n",
       " 'VL': -60,\n",
       " 'VL_v': 0.01,\n",
       " 'dt': 0.1,\n",
       " 'gCa': 4.4,\n",
       " 'gCa_v': 0.01,\n",
       " 'gK': 8,\n",
       " 'gK_v': 0.01,\n",
       " 'gL': 2.0,\n",
       " 'gL_v': 0.01,\n",
       " 'phi': 0.04,\n",
       " 'phi_v': 0.01,\n",
       " 'tend': 60000}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DictTable(metadata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Individual Neuron Time Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def ReadFileIndividualNeuron(filename, column=0):\n",
    "    filedata = []\n",
    "    with open(filename, 'r') as f:\n",
    "        for line in f:\n",
    "            ld = []\n",
    "            dataline = line.rstrip(', \\n').lstrip(' ').split(',')\n",
    "            filedata.append(np.array([dataline[0],dataline[column+1]])) # +1 is here becuase the first column is always time. \n",
    "    return np.array(filedata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def VisTimeSeries(datafolder, neurons=[0],output='Save'):\n",
    "    \n",
    "    with open(datafolder+\"/Parameters.json\") as data_file:\n",
    "            metadata = json.load(data_file)\n",
    "    p = metadata[\"NeuronsPerFile\"]\n",
    "    \n",
    "    filenumbers = []\n",
    "    datacolumns = []\n",
    "    for n in neurons:\n",
    "        filenumbers.append(int(n/p))\n",
    "        datacolumns.append(n%p)\n",
    "    \n",
    "    datafiles = glob.glob(datafolder+\"/*.dat\")\n",
    "    \n",
    "    files = [datafiles[n] for n in filenumbers]\n",
    "\n",
    "    fig = plt.figure(figsize=(25,2*len(files)))\n",
    "    \n",
    "    for i, file in enumerate(files):\n",
    "        ax = fig.add_subplot(len(files),1,i+1)\n",
    "        data = ReadFileIndividualNeuron(file,column=datacolumns[i])\n",
    "        p=plt.plot(data[:,0], data[:,1], rasterized=True)\n",
    "        plt.ylim([-90,90])\n",
    "        plt.setp(p,'Color', [0.7,0.3,0.3], 'linewidth', 3)\n",
    "        plt.ylabel('{}'.format(neurons[i]))\n",
    "        plt.grid(True)\n",
    "    plt.xlabel('Time')\n",
    "    if output=='Show':\n",
    "        plt.show()    \n",
    "    else:\n",
    "        plt.savefig(datafolder +'/Vis/IndividualTimeSeries.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "VisTimeSeries(SimPath,neurons=[1,10,500,1000],output='Save')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aggregate Time Frequency Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def ReadFile(filename, filenumber=0, perfile=200, threashold=40):\n",
    "    filedata = []\n",
    "    with open(filename, 'r') as f:\n",
    "        for line in f:\n",
    "            ld = []\n",
    "            dataline = line.rstrip(', \\n').lstrip(' ').split(',')\n",
    "            for i,data in enumerate(dataline[1:]):\n",
    "                if data == 'none':\n",
    "                    data = 0\n",
    "                if float(data) > threashold:\n",
    "                    ld.append(np.array([float(dataline[0]), perfile*filenumber + int(i)]))\n",
    "            \n",
    "            if len(ld)>0:\n",
    "                filedata.append(ld)\n",
    "    return filedata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def VisTimeFreq(datafolder, cuttoff=50, output = 'Save',figsize=(25,10)):\n",
    "    \n",
    "    with open(datafolder+\"/Parameters.json\") as data_file:\n",
    "            metadata = json.load(data_file)\n",
    "    \n",
    "    datafiles = glob.glob(datafolder+\"/*.dat\")\n",
    "\n",
    "    fig = plt.figure(figsize=figsize)\n",
    "    ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "    for i,file in enumerate(datafiles):\n",
    "        f = ReadFile(file,filenumber=i,perfile=metadata[\"NeuronsPerFile\"],threashold=cuttoff)\n",
    "        if len(f)>0:\n",
    "            data = np.array([item for sublist in f for item in sublist])\n",
    "            ax.scatter(data[:,0], data[:,1], c=[0.7]*3, s=2, rasterized=True)\n",
    "    if output=='Show':\n",
    "        plt.show()    \n",
    "    else:\n",
    "        plt.savefig(datafolder +'/Vis/TimeFreq.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "VisTimeFreq(SimPath,70,output='Save',figsize=(25,15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sorting Neurons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def SortNeurons():\n",
    "    d = []\n",
    "    neurontoindex = {}\n",
    "    coordinates = np.genfromtxt(SimPath+\"/Positions.csv\", delimiter=',')\n",
    "    for nxy in coordinates:\n",
    "        d.append((nxy[0],nxy[1]**2+nxy[2]**2))\n",
    "    sl = sorted(d, key=lambda x: x[1])\n",
    "    SortedNeurons = [int(x[0]) for x in sl]\n",
    "    for i,n in enumerate(SortedNeurons):\n",
    "        neurontoindex[n] = i\n",
    "    \n",
    "    return neurontoindex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def VisAdjacencyMatrix(datafolder, sort=False, numberoffiles=2, output='Save',figsize=(25,25)):\n",
    "    \n",
    "    with open(datafolder+\"/Parameters.json\") as data_file:\n",
    "            metadata = json.load(data_file)\n",
    "    \n",
    "    networkfiles = glob.glob(datafolder+\"/Network/*.csv\")\n",
    "    \n",
    "    if numberoffiles=='All':\n",
    "        files = networkfiles\n",
    "    else:\n",
    "        files = networkfiles[0:numberoffiles]\n",
    "    \n",
    "    fig = plt.figure(figsize=figsize)\n",
    "    ax = fig.add_subplot(1,1,1)\n",
    "    \n",
    "    if sort:\n",
    "        SortedNeruons = SortNeurons()\n",
    "    \n",
    "    for i,file in enumerate(files):\n",
    "        data = np.genfromtxt(file, delimiter=',')\n",
    "        if sort:\n",
    "            xdata = np.array([SortedNeruons[d] for d in data[:,0]])\n",
    "            ydata = np.array([SortedNeruons[d] for d in data[:,1]])\n",
    "        else:\n",
    "            xdata = data[:,0]\n",
    "            ydata = data[:,1]\n",
    "        weights = data[:,2]\n",
    "        plt.scatter(xdata, ydata, c=weights, s=5, cmap='Blues', rasterized=True)\n",
    "    if sort:\n",
    "        ax.set_xticklabels(SortedNeruons.keys())\n",
    "        ax.set_yticklabels(SortedNeruons.keys())\n",
    "    plt.colorbar()\n",
    "    if output=='Show':\n",
    "        plt.show()    \n",
    "    else:\n",
    "        plt.savefig(datafolder +'/Vis/AdjacencyMatrix.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VisAdjacencyMatrix(SimPath, sort=True, numberoffiles='All', output='Save', figsize=(25,20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def DevelopNetwork(N=800):\n",
    "    WeightsP = []\n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            wd = GetWeight(i,j)\n",
    "            WeightsP.append(np.array([i,j,wd]))\n",
    "\n",
    "    return np.array(WeightsP)\n",
    "    \n",
    "def GetWeight(n1=1, n2=2):\n",
    "    if n1==n2:\n",
    "        w = 0\n",
    "    else:\n",
    "        d = np.sqrt(Distance2(n1, n2))\n",
    "        w = min(int(np.random.normal(100,5)*np.exp(-d/(np.random.normal(20,1)))), 500)\n",
    "    return w\n",
    "\n",
    "def Distance2(a, b):\n",
    "        return (a - b)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data=DevelopNetwork(800)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x12cb21a58>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(15,13))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "data = np.array(data)\n",
    "xdata = data[:,0]\n",
    "ydata = data[:,1]\n",
    "ws = data[:,2]\n",
    "plt.scatter(xdata, ydata, c=ws, s=40, cmap='Blues', rasterized=True)\n",
    "plt.colorbar()\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}