dcm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/pytorch_p27/lib/python2.7/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #2\n",
      "  (fname, cnt))\n",
      "/home/ubuntu/anaconda3/envs/pytorch_p27/lib/python2.7/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #3\n",
      "  (fname, cnt))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: agg\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import torch as T\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "import scipy.linalg\n",
    "from functools import partial\n",
    "%pylab\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "plt.ioff()\n",
    "import matplotlib.gridspec as gridspec\n",
    "import scipy.sparse as sparse\n",
    "from scipy import stats\n",
    "from __future__ import print_function\n",
    "import gc\n",
    "from tqdm import tqdm\n",
    "from __future__ import division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$x_{t+1} = (A + pB)x_t + Cu_{t+1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def passivity(t,k=0.05,t0=400):\n",
    "    return 1/(1+np.exp(-k*(t-t0)))\n",
    "\n",
    "def diag_idx(n):\n",
    "    return [i for i in range(n)],[i for i in range(n)]\n",
    "\n",
    "def makeStableMatrix(n, density=0.1):\n",
    "    # TODO: implement on GPU?\n",
    "    eig = np.diag(np.random.uniform(-1,0,n))\n",
    "    v = scipy.linalg.orth(np.random.uniform(-1,1,(n,n)))\n",
    "    A = np.matmul(np.matmul(v.T, eig), v)\n",
    "    # need to make A sparse\n",
    "    indices = np.reshape(np.indices((n,n)),[2,-1])\n",
    "    mask = np.eye(n)\n",
    "    # may create density slightly less than desired if choice is on diagonal\n",
    "    idx = indices[:,np.random.choice(np.arange(indices.shape[1]),int(np.ceil(density*n**2-n)),replace=False)]\n",
    "    mask[idx[0], idx[1]] = 1\n",
    "    A[np.logical_not(mask)] = 0\n",
    "    return A\n",
    "\n",
    "def step(A,B,C,u,p,x,dt=1):\n",
    "    dxdt = T.matmul((A + p*B), x) + C * u\n",
    "    return dxdt + x\n",
    "\n",
    "def step_batch(A,B,C,u,p,x,dt=1):\n",
    "    dxdt = (T.matmul((A + p[:,None,None]*B), x[:,:,None])).squeeze() + u[:,None]*C\n",
    "    return dxdt + x\n",
    "\n",
    "def sim(A,B,C,u,p,x0,e=0.05):\n",
    "    ntime = u.shape[0]\n",
    "    nfeatures = x0.shape[0]\n",
    "    time = T.arange(ntime,dtype=T.int32)\n",
    "    x = T.zeros(ntime, x0.shape[0]).cuda()\n",
    "    z = T.zeros(nfeatures).cuda()\n",
    "    x[0] = x0\n",
    "    for t in range(1,ntime):\n",
    "        if e==0:\n",
    "            x[t] = step(A,B,C,u[t],p[t],x[t-1])\n",
    "        else:\n",
    "            x[t] = step(A,B,C,u[t],p[t],x[t-1]) + T.normal(z,e).cuda()\n",
    "    return x\n",
    "\n",
    "def generate_data(sim_time, nstim,nfeatures, burn_in=400, test_time=200, e=0.01, k=0.05, t0=400, density=0.2):\n",
    "    ntime = sim_time+burn_in+test_time\n",
    "    time = T.from_numpy(np.arange(ntime)).cuda()\n",
    "    A_true = T.from_numpy(makeStableMatrix(nfeatures,density).astype(np.float32)).cuda()\n",
    "    B_true = T.from_numpy(makeStableMatrix(nfeatures,density).astype(np.float32)).cuda()\n",
    "    C_true = T.from_numpy(np.random.normal(0,0.05,nfeatures).astype(np.float32)).cuda()\n",
    "    # C_true = T.from_numpy(makeStableMatrix(nfeatures).astype(np.float32)).cuda()\n",
    "    x0 = T.from_numpy(np.random.normal(0,0.05,nfeatures).astype(np.float32)).cuda()\n",
    "    u = T.zeros(ntime).cuda()\n",
    "    u[np.arange(4,ntime,ntime/nstim)] = 1\n",
    "\n",
    "    p1 = np.vectorize(partial(passivity,k=k,t0=t0))\n",
    "    time = np.arange(ntime)\n",
    "    p_true = p1(time).astype(np.float32)\n",
    "    p_true = T.from_numpy(p_true).cuda()\n",
    "#     p_true = T.zeros(ntime).cuda() # TODO remove me\n",
    "    x_true = sim(A_true,B_true,C_true,u,p_true,x0,e)\n",
    "    train = (time[burn_in:-test_time], u[burn_in:-test_time],\n",
    "             p_true[burn_in:-test_time], x_true[burn_in:-test_time])\n",
    "    test = (time[-test_time:], u[-test_time:], p_true[-test_time:], x_true[-test_time:])\n",
    "    return A_true, B_true, C_true, train, test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FishSeqData(Dataset):    \n",
    "    def __init__(self, u, p, x,n_future_steps=1):\n",
    "        self.x = nn.Parameter(x,requires_grad=False)\n",
    "        self.p = nn.Parameter(p,requires_grad=False)\n",
    "        self.u = nn.Parameter(u,requires_grad=False)\n",
    "        self.nfeatures = x.shape[1]\n",
    "        self.n_future_steps = n_future_steps\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.x)-self.n_future_steps\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        indices = slice(idx,idx+self.n_future_steps)\n",
    "        x_true_indices = slice(idx+1,idx+self.n_future_steps+1)\n",
    "        return (self.u[indices], self.p[indices],\n",
    "                self.x[indices], self.x[x_true_indices])\n",
    "\n",
    "class DynamicsSeq(nn.Module):\n",
    "    def __init__(self, nfeatures, n_future_steps,dtype=T.float32, scale=1,std=0.1):\n",
    "        super(DynamicsSeq, self).__init__()\n",
    "        if dtype==T.float32:\n",
    "            tensor = T.cuda.FloatTensor\n",
    "        elif dtype==T.float16:\n",
    "            tensor = T.cuda.HalfTensor\n",
    "                \n",
    "        self.A = nn.Parameter(tensor(nfeatures,nfeatures).normal_(std),requires_grad=True)\n",
    "        self.B = nn.Parameter(tensor(nfeatures,nfeatures).normal_(std),requires_grad=True)\n",
    "        self.C = nn.Parameter(tensor(nfeatures).normal_(std),requires_grad=True)\n",
    "        self.n_future_steps = n_future_steps\n",
    "        self.tensor = tensor\n",
    "        self.scale = scale\n",
    "        self.dtype = dtype\n",
    "\n",
    "    def forward(self, u, p, x_true, n_future_steps=None):\n",
    "        if n_future_steps==None:\n",
    "            n_future_steps = self.n_future_steps\n",
    "        x = self.tensor(x_true.shape[0], 1+x_true.shape[1], *x_true.shape[2:]).zero_()\n",
    "        x[:,0] = x_true[:,0]\n",
    "        for t in range(n_future_steps):\n",
    "            u[ :,t,None]*self.C\n",
    "            dxdt = (T.matmul((self.A + p[:,t,None,None]*self.B), x_true[:,t,:,None]).squeeze()) + u[ :,t,None]*self.C\n",
    "            x[:,t+1] = dxdt + x[:,t]\n",
    "        return x[:,1:]\n",
    "\n",
    "class Dynamics(nn.Module):\n",
    "    def __init__(self, nfeatures):\n",
    "        super(Dynamics, self).__init__()\n",
    "        self.A = nn.Parameter(T.normal(T.zeros(nfeatures,nfeatures),0.5),requires_grad=True)\n",
    "        self.B = nn.Parameter(T.normal(T.zeros(nfeatures,nfeatures),0.5),requires_grad=True)\n",
    "        self.C = nn.Parameter(T.normal(T.zeros(nfeatures),0.5),requires_grad=True)\n",
    "\n",
    "    def forward(self, u, p, x):\n",
    "        return (x[:,0] + (T.matmul((self.A + p[:,0,None,None]*self.B), x[:,0,:,None]).squeeze()) + u[:,0,None] * self.C)[:,None]\n",
    "\n",
    "\n",
    "def train(model,data,nepochs=10, lambdaA=(1e-8, 1e-6), lambdaB=(1e-6, 1e-6), lr=0.1, verbose=True):\n",
    "    dataloader = DataLoader(data, batch_size=batch_size, shuffle=True)\n",
    "    if verbose:\n",
    "        A_loss = F.mse_loss(model.A.data,A_true)\n",
    "        print(\"A_loss: {}\".format(A_loss))\n",
    "    for batch_data in tqdm(dataloader):\n",
    "            U,P,X, X_true = batch_data\n",
    "            X_pred = model(U,P,X)\n",
    "            mse_loss = F.mse_loss(X_pred.float(),X_true.float())\n",
    "            print(\"pred loss: {}\".format(mse_loss))\n",
    "            break\n",
    "        #     optimizer = T.optim.SGD(model.parameters(),lr=lr)\n",
    "    optimizer = T.optim.Adam(model.parameters(),lr=lr)\n",
    "    for e in range(nepochs):\n",
    "        if verbose:\n",
    "            print(\"epoch {}: \".format(e), end=\"\")\n",
    "        cum_loss = 0\n",
    "        for batch_data in tqdm(dataloader):\n",
    "            U,P,X, X_true = batch_data\n",
    "            X_pred = model(U,P,X)\n",
    "            l_A = lambdaA[0] * model.A.norm(1) + lambdaA[1] * model.A.norm(2)\n",
    "            l_B = lambdaB[0] * model.B.norm(1) + lambdaB[1] * model.B.norm(2)\n",
    "            mse_loss = F.mse_loss(X_pred,X_true)\n",
    "            loss = mse_loss + l_A + l_B\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            cum_loss += float(loss)\n",
    "            del X_pred, U,P,X, X_true, mse_loss, l_A, l_B, loss\n",
    "            gc.collect()\n",
    "            torch.cuda.empty_cache()\n",
    "\n",
    "        if verbose:\n",
    "            A_loss = F.mse_loss(model.A.data,A_true)\n",
    "            B_loss = F.mse_loss(model.B.data,B_true)\n",
    "            C_loss = F.mse_loss(model.C.data,C_true)\n",
    "            print(\"pred_loss: {}, A_loss: {}, B_loss: {}, C_loss: {}\".format(cum_loss,A_loss,B_loss,C_loss))\n",
    "        print(\"pred_loss: {}\".format(cum_loss))\n",
    "    \n",
    "    if verbose:\n",
    "        print(\"pred_loss: {}, A_loss: {}, B_loss: {}, C_loss: {}\".format(cum_loss,A_loss,B_loss,C_loss))\n",
    "\n",
    "def set_grad(params, params_with_grad):\n",
    "\n",
    "    for param, param_w_grad in zip(params, params_with_grad):\n",
    "        if param.grad is None:\n",
    "            param.grad = torch.nn.Parameter(param.data.new().resize_(*param.data.size()))\n",
    "        param.grad.data.copy_(param_w_grad.grad.data)\n",
    "    \n",
    "def train_fp16(model,data,nepochs=10, lambdaA=(1e-8, 1e-6), lambdaB=(1e-6, 1e-6), lr=0.1, verbose=True,loss_scale=1):\n",
    "    dataloader = DataLoader(data, batch_size=batch_size, shuffle=True)\n",
    "    param_copy = [param.clone().type(torch.cuda.FloatTensor).detach() for param in model.parameters()]\n",
    "    for batch_data in tqdm(dataloader):\n",
    "            U,P,X, X_true = batch_data\n",
    "            X_pred = model(U,P,X)\n",
    "            mse_loss = F.mse_loss(X_pred.float(),X_true.float())\n",
    "            print(\"pred loss: {}\".format(mse_loss))\n",
    "            break\n",
    "    \n",
    "    if verbose:\n",
    "        A_loss = F.mse_loss(param_copy[0].data/model.scale,A_true)\n",
    "        print(\"A_loss: {}\".format(A_loss))\n",
    "#         optimizer = T.optim.SGD(model.parameters(),lr=lr)\n",
    "    for param in param_copy:\n",
    "        param.requires_grad = True\n",
    "    optimizer = torch.optim.SGD(param_copy, lr)\n",
    "#     optimizer = T.optim.Adam(param_copy,lr=lr)\n",
    "    nfeatures = model.A.shape[0]\n",
    "#     nondiagonal = ~T.eye(nfeatures,dtype=T.uint8)\n",
    "    for e in range(nepochs):\n",
    "        if verbose:\n",
    "            print(\"epoch {}: \".format(e), end=\"\")\n",
    "        cum_loss = 0\n",
    "        for batch_data in tqdm(dataloader):\n",
    "            U,P,X, X_true = batch_data\n",
    "            X_pred = model(U,P,X)\n",
    "            l_A = lambdaA[0] * model.A.float().norm(1) + lambdaA[1] * model.A.float().norm(2)\n",
    "            l_B = lambdaB[0] * model.B.float().norm(1) + lambdaB[1] * model.B.float().norm(2)\n",
    "#             l_A = lambdaA[0] * model.A[nondiagonal].float().norm(1) + lambdaA[1] * model.A[nondiagonal].float().norm(2)\n",
    "#             l_B = lambdaB[0] * model.B.float().norm(1) + lambdaB[1] * model.B.float().norm(2)\n",
    "\n",
    "            mse_loss = F.mse_loss(X_pred,X_true).float()\n",
    "            loss = (mse_loss + l_A + l_B) * loss_scale\n",
    "\n",
    "            model.zero_grad()\n",
    "            loss.backward()\n",
    "            set_grad(param_copy, list(model.parameters()))\n",
    "            if loss_scale != 1:\n",
    "                for param in param_copy:\n",
    "                    param.grad.data = param.grad.data/loss_scale\n",
    "            optimizer.step()\n",
    "            params = list(model.parameters())\n",
    "            for i in range(len(params)):\n",
    "                params[i].data.copy_(param_copy[i].data)\n",
    "\n",
    "            cum_loss += float(loss)/loss_scale\n",
    "    #             del X_pred, U,P,X, X_true, mse_loss, l_A, l_B, loss\n",
    "    #             gc.collect()\n",
    "    #             torch.cuda.empty_cache()\n",
    "\n",
    "        if verbose:\n",
    "            A_loss = F.mse_loss(param_copy[0].data/model.scale,A_true)\n",
    "            B_loss = F.mse_loss(param_copy[1].data/model.scale,B_true)\n",
    "            C_loss = F.mse_loss(param_copy[2].data/model.scale,C_true)\n",
    "            print(\"pred_loss: {}, A_loss: {}, B_loss: {}, C_loss: {}\".format(cum_loss,A_loss,B_loss,C_loss))\n",
    "        print(\"pred_loss: {}\".format(cum_loss))\n",
    "\n",
    "    if verbose:\n",
    "        print(\"pred_loss: {}, A_loss: {}, B_loss: {}, C_loss: {}\".format(cum_loss,A_loss,B_loss,C_loss))\n",
    "\n",
    "\n",
    "def model_v_truth(model,u,p,x_true,A_true, B_true):\n",
    "    if model.dtype==T.float16:\n",
    "        A = model.A.data.float()*model.scale\n",
    "        B = model.B.data.float()*model.scale\n",
    "    else:\n",
    "        A = model.A.data\n",
    "        B = model.B.data\n",
    "    with T.no_grad():\n",
    "        x_pred = T.squeeze(model(u[:-1,None],p[:-1,None],x_true[:-1,None],n_future_steps=1))\n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "    spec = gridspec.GridSpec(ncols=2, nrows=3)\n",
    "    anno_opts = dict(xy=(0.5, 0.5), xycoords='axes fraction',\n",
    "                     va='center', ha='center')\n",
    "\n",
    "    ax1 = fig.add_subplot(spec[0,0:])\n",
    "    ax2 = fig.add_subplot(spec[1, 0])\n",
    "    ax3 = fig.add_subplot(spec[1, 1])\n",
    "    ax4 = fig.add_subplot(spec[2, 0])\n",
    "    ax5 = fig.add_subplot(spec[2, 1])\n",
    "    \n",
    "    dx_pred = x_pred - x_true[:-1]\n",
    "    ax1.plot(dx_pred.mean(1).cpu().numpy(),color='red', label=\"Model\")\n",
    "#     ax1.plot(x_pred[:,2].cpu().numpy(),color='red', label=\"Model\")\n",
    "    ax1.set_ylabel(\"dx/dt\")\n",
    "    ax1.set_xlabel(\"Time\")\n",
    "    ax1.set_title(\"Witheld test data\")\n",
    "    dx_true = x_true[1:] - x_true[:-1]\n",
    "    ax1.plot(dx_true.mean(1).cpu().numpy(),color=\"gray\",linewidth=5, alpha=0.7,label=\"Truth\")\n",
    "    ax1.legend()\n",
    "    \n",
    "    mymax = max(A_true.max(), A.max())\n",
    "    mymin = min(A_true.min(), A.min())\n",
    "    im = ax2.imshow(A_true.cpu(),vmin=mymin,vmax=mymax)\n",
    "    ax2.set_title(\"A true\")\n",
    "    ax3.imshow(A.cpu(),vmin=mymin,vmax=mymax)\n",
    "    ax3.set_title(\"A model\")\n",
    "#     cax,kw = mpl.colorbar.make_axes([ax2, ax3])\n",
    "#     fig.colorbar(im, cax=cax, **kw)\n",
    "    \n",
    "    mymax = max(B_true.max(), B.max())\n",
    "    mymin = min(B_true.min(), B.min())\n",
    "    im2 = ax4.imshow(B_true.cpu(),vmin=mymin,vmax=mymax)\n",
    "    ax4.set_title(\"B true\")\n",
    "    ax5.imshow(B.cpu(),vmin=mymin,vmax=mymax)\n",
    "    ax5.set_title(\"B model\")\n",
    "#     cax,kw = mpl.colorbar.make_axes([ax4, ax5])\n",
    "#     fig.colorbar(im2, cax=cax, **kw)\n",
    "    \n",
    "    fig.tight_layout()\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate Half precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ntime = 2826\n",
    "nstim = 30\n",
    "nfeatures = 15888\n",
    "\n",
    "u_train = T.cuda.HalfTensor(ntime).uniform_()\n",
    "p_train = T.cuda.HalfTensor(ntime).uniform_()\n",
    "time_train = T.arange(ntime).half().cuda()\n",
    "x_train = T.cuda.HalfTensor(ntime,nfeatures).uniform_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.66918084025383"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ntime*3+ntime*nfeatures)*16/1024**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_future_steps = 1\n",
    "batch_size = 1\n",
    "\n",
    "data = FishSeqData(u_train,p_train,x_train,n_future_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = DynamicsSeq(data.nfeatures,n_future_steps,T.float16,1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/2825 [00:00<?, ?it/s]Exception KeyError: KeyError(<weakref at 0x7f9a6b737368; to 'tqdm' at 0x7f99fe27bc50>,) in <bound method tqdm.__del__ of   0%|          | 0/2825 [00:00<?, ?it/s]> ignored\n",
      "  0%|          | 2/2825 [00:00<03:56, 11.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred loss: inf\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 142/2825 [00:11<03:32, 12.65it/s]"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-9cc44e497ab2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtrain_fp16\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1e-4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1e-5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1e-3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1e-3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss_scale\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m512\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mtime_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mu_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmodel_v_truth\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mu_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mA_true\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mB_true\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-3-4557dff9c541>\u001b[0m in \u001b[0;36mtrain_fp16\u001b[0;34m(model, data, nepochs, lambdaA, lambdaB, lr, verbose, loss_scale)\u001b[0m\n\u001b[1;32m    145\u001b[0m                 \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam_copy\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    146\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 147\u001b[0;31m             \u001b[0mcum_loss\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mloss_scale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    148\u001b[0m     \u001b[0;31m#             del X_pred, U,P,X, X_true, mse_loss, l_A, l_B, loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    149\u001b[0m     \u001b[0;31m#             gc.collect()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 142/2825 [00:29<09:26,  4.73it/s]"
     ]
    }
   ],
   "source": [
    "train_fp16(model,data,15,(1e-4,1e-5),(1e-3,0),lr=1e-3,verbose=False, loss_scale=512)\n",
    "time_test, u_test, p_test, x_test = test_data\n",
    "model_v_truth(model, u_test, p_test, x_test, A_true.data, B_true.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ntime = 2826\n",
    "nstim = 30\n",
    "nfeatures = 15888\n",
    "\n",
    "u_train = T.cuda.FloatTensor(ntime).uniform_()\n",
    "p_train = T.cuda.FloatTensor(ntime).uniform_()\n",
    "time_train = T.arange(ntime).cuda()\n",
    "x_train = T.cuda.FloatTensor(ntime,nfeatures).uniform_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_future_steps = 1\n",
    "batch_size = 1\n",
    "\n",
    "data = FishSeqData(u_train,p_train,x_train,n_future_steps)\n",
    "model = DynamicsSeq(data.nfeatures,n_future_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 856/2825 [03:26<07:54,  4.15it/s]"
     ]
    }
   ],
   "source": [
    "train(model,data,1,(1e-4,1e-5),(1e-3,1e-4),lr=0.1,verbose=False)\n",
    "# time_test, u_test, p_test, x_test = test_data\n",
    "# model_v_truth(model, u_test, p_test, x_test, A_true.data, B_true.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sim "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ntime = 3000\n",
    "nstim = 30\n",
    "nfeatures = 10\n",
    "A_true, B_true, C_true, train_data, test_data = generate_data(ntime, nstim,nfeatures,burn_in=200, e=0.1,k=1,t0=1e10)\n",
    "\n",
    "time_train, u_train, p_train, x_train = train_data\n",
    "time_test, u_test, p_test, x_test = test_data\n",
    "\n",
    "scale = 8\n",
    "\n",
    "fig, ax = plt.subplots(1,2,figsize=(10,5))\n",
    "ax[0].plot(time_train,p_train.cpu().numpy())\n",
    "ax[0].set_ylabel(\"Passivity\")\n",
    "ax[0].set_xlabel(\"Time\")\n",
    "\n",
    "ax[1].plot(x_train[:,2].cpu().numpy())\n",
    "ax[1].set_title(\"Ground Truth\")\n",
    "ax[1].set_ylabel(\"df/f\")\n",
    "ax[1].set_xlabel(\"Time\")\n",
    "fig.tight_layout()\n",
    "fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_future_steps = 1\n",
    "batch_size = 10\n",
    "\n",
    "data = FishSeqData(u_train,p_train,x_train,n_future_steps)\n",
    "model = DynamicsSeq(data.nfeatures,n_future_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 3/300 [00:00<00:10, 29.06it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A_loss: 1.22243654728\n",
      "epoch 0: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:09<00:00, 31.20it/s]\n",
      "  1%|          | 3/300 [00:00<00:10, 27.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 31.9146524547, A_loss: 0.041522115469, B_loss: 0.0212900880724, C_loss: 0.407817751169\n",
      "pred_loss: 31.9146524547\n",
      "epoch 1: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:10<00:00, 29.61it/s]\n",
      "  1%|▏         | 4/300 [00:00<00:09, 31.42it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 4.41125610983, A_loss: 0.00106719601899, B_loss: 0.0213134605438, C_loss: 0.147408589721\n",
      "pred_loss: 4.41125610983\n",
      "epoch 2: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:09<00:00, 30.94it/s]\n",
      "  1%|▏         | 4/300 [00:00<00:09, 31.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 3.40441890107, A_loss: 0.000590472307522, B_loss: 0.0213184133172, C_loss: 0.0456914715469\n",
      "pred_loss: 3.40441890107\n",
      "epoch 3: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:09<00:00, 31.04it/s]\n",
      "  1%|▏         | 4/300 [00:00<00:09, 30.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 3.21544327168, A_loss: 0.000612090167124, B_loss: 0.0213361550122, C_loss: 0.0144518595189\n",
      "pred_loss: 3.21544327168\n",
      "epoch 4: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:09<00:00, 31.13it/s]\n",
      "  1%|▏         | 4/300 [00:00<00:09, 31.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 3.15928539773, A_loss: 0.000536397274118, B_loss: 0.0213139038533, C_loss: 0.00340078724548\n",
      "pred_loss: 3.15928539773\n",
      "epoch 5: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:09<00:00, 30.92it/s]\n",
      "  1%|▏         | 4/300 [00:00<00:09, 31.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 3.14922978915, A_loss: 0.000806712138001, B_loss: 0.0213187746704, C_loss: 0.00359702995047\n",
      "pred_loss: 3.14922978915\n",
      "epoch 6: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:09<00:00, 30.97it/s]\n",
      "  1%|▏         | 4/300 [00:00<00:09, 31.60it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 3.14814150054, A_loss: 0.000945926294662, B_loss: 0.0213333647698, C_loss: 0.00277419132181\n",
      "pred_loss: 3.14814150054\n",
      "epoch 7: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:09<00:00, 30.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 3.15451791417, A_loss: 0.000647119188216, B_loss: 0.0213116630912, C_loss: 0.00251636886969\n",
      "pred_loss: 3.15451791417\n",
      "pred_loss: 3.15451791417, A_loss: 0.000647119188216, B_loss: 0.0213116630912, C_loss: 0.00251636886969\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train(model,data,8,(1e-4,0),(1e-3,1e-4),lr=1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 5 Axes>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_v_truth(model, u_test, p_test, x_test, A_true.data, B_true.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 56/2999 [00:00<00:05, 553.60it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A_loss: 1.14885008335\n",
      "epoch 0: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 547.52it/s]\n",
      "  2%|▏         | 57/2999 [00:00<00:05, 564.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 970.302741691, A_loss: 1.12238240242, B_loss: 1.18244886398, C_loss: 0.361779123545\n",
      "pred_loss: 970.302741691\n",
      "epoch 1: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 552.59it/s]\n",
      "  2%|▏         | 57/2999 [00:00<00:05, 561.87it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 953.002928384, A_loss: 1.09656023979, B_loss: 1.17737352848, C_loss: 0.357613861561\n",
      "pred_loss: 953.002928384\n",
      "epoch 2: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 552.62it/s]\n",
      "  2%|▏         | 57/2999 [00:00<00:05, 562.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 936.106647916, A_loss: 1.07136487961, B_loss: 1.17231607437, C_loss: 0.353502690792\n",
      "pred_loss: 936.106647916\n",
      "epoch 3: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 537.66it/s]\n",
      "  2%|▏         | 55/2999 [00:00<00:05, 541.14it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 919.627376951, A_loss: 1.04678177834, B_loss: 1.16727638245, C_loss: 0.349444180727\n",
      "pred_loss: 919.627376951\n",
      "epoch 4: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 537.74it/s]\n",
      "  2%|▏         | 55/2999 [00:00<00:05, 541.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 903.539994083, A_loss: 1.02279376984, B_loss: 1.16225421429, C_loss: 0.345437914133\n",
      "pred_loss: 903.539994083\n",
      "epoch 5: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 532.98it/s]\n",
      "  2%|▏         | 55/2999 [00:00<00:05, 542.59it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 887.845618337, A_loss: 0.99938672781, B_loss: 1.15724682808, C_loss: 0.341483682394\n",
      "pred_loss: 887.845618337\n",
      "epoch 6: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 537.73it/s]\n",
      "  2%|▏         | 57/2999 [00:00<00:05, 562.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 872.519791916, A_loss: 0.976547181606, B_loss: 1.15225625038, C_loss: 0.337580174208\n",
      "pred_loss: 872.519791916\n",
      "epoch 7: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 552.59it/s]\n",
      "  2%|▏         | 57/2999 [00:00<00:05, 565.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 857.576278865, A_loss: 0.954258739948, B_loss: 1.14728271961, C_loss: 0.333726584911\n",
      "pred_loss: 857.576278865\n",
      "epoch 8: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2999/2999 [00:05<00:00, 552.63it/s]\n",
      "  2%|▏         | 57/2999 [00:00<00:05, 562.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred_loss: 842.993564084, A_loss: 0.932507574558, B_loss: 1.14232373238, C_loss: 0.329922020435\n",
      "pred_loss: 842.993564084\n",
      "epoch 9: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▌   | 1959/2999 [00:03<00:01, 552.78it/s]"
     ]
    }
   ],
   "source": [
    "n_future_steps = 1\n",
    "batch_size = 1\n",
    "\n",
    "scale = 1\n",
    "time_train, u_train, p_train, x_train = time_train, u_train.half()*scale, p_train.half()*scale, x_train.half()*scale\n",
    "time_test, u_test, p_test, x_test = time_test, u_test.half()*scale, p_test.half()*scale, x_test.half()*scale\n",
    "data = FishSeqData(u_train,p_train,x_train,n_future_steps)\n",
    "model = DynamicsSeq(data.nfeatures,n_future_steps,T.float16,scale)\n",
    "train_fp16(model,data,15,(1e-4,1e-5),(1e-3,0),lr=1e-3,verbose=True, loss_scale=512)\n",
    "\n",
    "model_v_truth(model, u_test, p_test, x_test, A_true.data, B_true.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fish code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Augment the PythonPath so python can find necessary code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys, datetime\n",
    "LF_CODE_PATH = os.path.expanduser('~/projects/LFAnalyze/code')\n",
    "FT_CODE_PATH = os.path.expanduser('~/projects/fishTrax/code/analysis/')\n",
    "FD_CODE_PATH = os.path.expanduser('~/projects/fish_despair_notebooks/src/')\n",
    "sys.path.insert(0,LF_CODE_PATH)\n",
    "sys.path.insert(0,FT_CODE_PATH)\n",
    "sys.path.insert(0,FD_CODE_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import useful python packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import pims\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import skimage.io\n",
    "import visualization_utils as vizutil\n",
    "import seaborn as sns\n",
    "from skimage.filters import gaussian_filter\n",
    "import gc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the data\n",
    "\n",
    "passivity_2p_imaging_utils provides a list of all the datasets and provides a helper class to make loading the data easy.\n",
    "\n",
    "The data_sets are split into three conditions... (the keynames are wierd for historical reasons)   \n",
    "'enp': control group - no shocks at all.  \n",
    "'c': experimental group - fish experience behavioral challenge (repeated shocks) while being imaged  \n",
    "'e': reexposed group - first fish experience free-swimming behavioral challenge... then are imaged during behavioral challenge\n",
    "  \n",
    "all_data is a dictionary keyed by the condition.  \n",
    "all_data[condition] contains a list of Passivity_2p_Fish objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "controls, n = 6\n",
      "experimental, n = 8\n",
      "reexposed, n = 12\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/pytorch_p27/lib/python2.7/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import passivity_2p_imaging_utils as p2putils\n",
    "reload(p2putils)\n",
    "tmp_dir = '/tmp/'\n",
    "all_data = p2putils.get_all_datasets(tmp_dir=tmp_dir)\n",
    "\n",
    "print('controls, n =', len(all_data['enp']))\n",
    "print('experimental, n =', len(all_data['c']))\n",
    "print('reexposed, n =', len(all_data['e']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some ideal example fish for modeling\n",
    "(see 2p_Fish_Figure3_Accumulation.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "experimental f01606\n",
      "reexposed f01555\n"
     ]
    }
   ],
   "source": [
    "print('experimental', all_data['c'][6].fishid)\n",
    "print('reexposed', all_data['e'][2].fishid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passivity_2p_Fish Class\n",
    "\n",
    "The `Passivity_2p_Fish` class offers various members and methods for loading data associated with each fish.  \n",
    "  \n",
    "Lets demo these methods using an example fish:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "fish = all_data['e'][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time of all volumes, tail_movements, and shocks are stored in the following variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first shock started at t= 448.9964299699543 s\n",
      "The first slice of the frame began being imaged at t= 12.446 s\n",
      "The first tail movement started at= 102.5907 s\n",
      "Num z-planes imaged: 11\n",
      "Volume-Rate: 1.0131832172386757\n"
     ]
    }
   ],
   "source": [
    "print('The first shock started at t=', fish.shock_st[0], 's') #shock start times\n",
    "print('The first slice of the frame began being imaged at t=', fish.frame_st[0,0], 's') #time at which each slice was imaged [#samples X #slices]\n",
    "print('The first tail movement started at=', fish.tail_movement_start_times[0], 's') #tail movement times - movements separted into forward swims, turns and escapes.\n",
    "print('Num z-planes imaged:', fish.num_zplanes)\n",
    "print('Volume-Rate:', 1/np.diff(fish.frame_st[:,0]).mean()) #frame_st is #frames x #slices, we examine interval between imaging first slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Demo code for examining movie of tail (slowed by factor of 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 581/581 [00:00<00:00, 5185.14it/s]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div align=middle><video width='150'src='data:video/mp4;base64,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' controls>Sorry, seems like your browser doesn't support HTML5 audio/video</video></div>"
      ],
      "text/plain": [
       "<moviepy.video.io.html_tools.HTML2 object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movement_ndx = 10\n",
    "clip = fish.get_tail_movie_clip(fish.tail_movement_start_times[movement_ndx]-.1, \n",
    "                             fish.tail_movement_end_times[movement_ndx]+.1, \n",
    "                             playback_speed_factor=.1)\n",
    "clip.ipython_display(width=150)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Demo code to plot tail movement rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'Time Relative to First Shock (s)')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rate_window_starts = np.arange(-300,31*60,60) + fish.shock_st[0] #1 minutes windows around start of shock\n",
    "rate_window_centers = rate_window_starts + 30\n",
    "rate_windows_adj = rate_window_starts - fish.td_time[0] #corrected for the fact that get_movement_rate wants time relative to start of tail imaging.\n",
    "plt.plot(rate_window_centers - fish.shock_st[0], [fish.get_movement_rate([x,x+60], bExcShockResp=False) for x in rate_windows_adj])\n",
    "plt.axvline(0,c='r')\n",
    "plt.ylabel('Movement Rate (Hz)')\n",
    "plt.xlabel('Time Relative to First Shock (s)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `get_roi_table` method returns a dataframe of all the rois for teh fish.  Each row of this table represents an ROI and specified the place the ROI is in, the pixels that are included in the ROI, the centroid of the ROI, and which brain regions the ROI is in.  \n",
    "\n",
    "Note, this data is older and was processed by simply segmenting the anatomical images.  Thus the data is does not look as clean as data that is cleaned up and processed using CNMF, for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = fish.get_roi_table() #this can be slow to run the first time as data is loaded from files\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "'get_signals_raw' returns a matrix containing the raw fluorescent signal associated with each ROI.  Each row of this matrix is associated with the corresponding row of the ROI table.  \n",
    "\n",
    "Note, I only use the second half of the signal matrix, because the agarose had not fully hardened during the first of imaging which cause the fish to drift in z slightly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = fish.get_signals_raw(z=None)\n",
    "#M = hbutils.df_over_f(M)\n",
    "print('Num ROIs:', df.shape[0])\n",
    "print('Shape of signal matrix', M.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also various methods for grabbing the raw imaging data:  \n",
    "get_tif_as_vol  \n",
    "get_tif_rasl\n",
    "\n",
    "We can use this to visualize a few ROIs in particular plane/slice and brain region:\n",
    "\n",
    "(**This won't work on AWS unless you upload tif stacks**)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Real data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dtype = np.float32\n",
    "x_fish = T.from_numpy(M.T.astype(dtype)).cuda()\n",
    "time_fish = T.from_numpy(fish.frame_st.mean(1).astype(dtype)).cuda()\n",
    "if dtype==np.float16:\n",
    "    u_fish = T.cuda.HalfTensor(time_fish.shape).zero_()\n",
    "    p_fish = T.cuda.HalfTensor(time_fish.shape).zero_()\n",
    "else:\n",
    "    u_fish = T.cuda.FloatTensor(time_fish.shape).zero_()\n",
    "    p_fish = T.cuda.FloatTensor(time_fish.shape).zero_()\n",
    "u_fish[numpy.searchsorted(fish.frame_et[:,-1], fish.shock_st,side=\"left\")] = 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_future_steps = 1\n",
    "batch_size = 1\n",
    "\n",
    "# data = FishSeqData(u_fish,p_fish,x_fish,n_future_steps)\n",
    "# model = DynamicsSeq(data.nfeatures,n_future_steps,T.float16)\n",
    "# train_fp16(model,data,15,(1e-4,1e-5),(1e-3,1e-4),lr=1e-3,verbose=False, loss_scale=512)\n",
    "\n",
    "data = FishSeqData(u_fish,p_fish,x_fish,n_future_steps)\n",
    "model = DynamicsSeq(data.nfeatures,n_future_steps)\n",
    "train(model,data,20,(1e-2,1e-3),(1e-1,1e-2),lr=1e-4,verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_future_steps = 1\n",
    "batch_size = 1\n",
    "\n",
    "# data = FishSeqData(u_fish,p_fish,x_fish,n_future_steps)\n",
    "# model = DynamicsSeq(data.nfeatures,n_future_steps,T.float16)\n",
    "# train_fp16(model,data,15,(1e-4,1e-5),(1e-3,1e-4),lr=1e-3,verbose=False, loss_scale=512)\n",
    "\n",
    "data = FishSeqData(u_fish,p_fish,x_fish,n_future_steps)\n",
    "model = DynamicsSeq(data.nfeatures,n_future_steps)\n",
    "train(model,data,20,(1e-2,1e-3),(1e-1,1e-2),lr=1e-4,verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "T.save(model.state_dict(),\"fish_dcm_fp32_epoch=20,lA=(1e-4,1e-5),lB=(1e-3,1e-4),lr=1e-4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(model.A[:100,:100].cpu().detach().numpy())\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0, device='cuda:0')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T.sum(model.A==0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[ 1.2827e+00, -4.2302e-01,  3.7024e-01,  ..., -1.9087e+00,\n",
       "          6.9277e-01, -1.9529e-01],\n",
       "        [ 2.2638e-01,  1.9356e-01, -5.7364e-01,  ..., -2.5845e-01,\n",
       "         -1.6772e-01,  1.4871e-01],\n",
       "        [ 3.2407e-01, -7.9197e-01,  7.9257e-01,  ...,  7.0335e-01,\n",
       "          1.0474e+00,  1.5562e+00],\n",
       "        ...,\n",
       "        [-1.2695e-01,  3.4202e-01,  1.1120e-02,  ..., -1.0017e+00,\n",
       "         -4.6733e-01, -7.9459e-01],\n",
       "        [ 1.6414e+00, -5.3083e-02, -1.0420e+00,  ..., -1.1365e+00,\n",
       "          1.5596e+00,  3.0564e-02],\n",
       "        [-9.2302e-01,  1.2445e+00,  2.9981e-01,  ..., -1.4010e-01,\n",
       "         -8.4665e-01, -6.2237e-01]], device='cuda:0')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.A"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Environment (conda_pytorch_p27)",
   "language": "python",
   "name": "conda_pytorch_p27"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}