TiDHy_SupFigures01.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2a0e1841-1962-46c0-a629-11e884c6c99c",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Load Libraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "014eaebf-52c1-4b95-a6d9-34a1b1525b1b",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=1)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import sys\n",
    "import os.path as op\n",
    "import ssm\n",
    "import itertools\n",
    "import autograd.numpy as np\n",
    "import matplotlib.pyplot as pltx\n",
    "import matplotlib.gridspec as gridspec\n",
    "import seaborn as sns\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "np.set_printoptions(suppress=True)\n",
    "\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "from torch.optim.lr_scheduler import ExponentialLR\n",
    "\n",
    "from tqdm.auto import tqdm\n",
    "from pathlib import Path\n",
    "from omegaconf import DictConfig, OmegaConf\n",
    "\n",
    "import TiDHy\n",
    "from TiDHy.utils.utils import *\n",
    "from TiDHy.datasets import load_dataset\n",
    "import TiDHy.utils.io_dict_to_hdf5 as ioh5\n",
    "from TiDHy.Evaluate_TiDHy import run_seq_len_model\n",
    "\n",
    "##### Plotting settings ######\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams.update({'font.size':          10,\n",
    "                     'axes.linewidth':     2,\n",
    "                     'xtick.major.size':   5,\n",
    "                     'ytick.major.size':   5,\n",
    "                     'xtick.major.width':  2,\n",
    "                     'ytick.major.width':  2,\n",
    "                     'axes.spines.right':  False,\n",
    "                     'axes.spines.top':    False,\n",
    "                     'pdf.fonttype':       42,\n",
    "                     'ps.fonttype':        42,\n",
    "                     'xtick.labelsize':    10,\n",
    "                     'ytick.labelsize':    10,\n",
    "                     'figure.facecolor':   'white',\n",
    "                     'pdf.use14corefonts': True,\n",
    "                     'font.family':        'sans-serif',\n",
    "                    #  'font.family':        'Arial',\n",
    "                    #  'font.sans-serif':    'Arial',\n",
    "                     'font.serif':         'Arial',\n",
    "                    })\n",
    "\n",
    "from matplotlib.colors import ListedColormap\n",
    "clrs = ['#1A237E','#7E57C2','#757575','#BDBDBD','#4CAF50','#FF9800','#795548','#FF4081','#00BCD4','#FF1744','#FFFFFF','#000000']\n",
    "cmap = ListedColormap(clrs)\n",
    "\n",
    "device = torch.device(1) #torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df481e9",
   "metadata": {},
   "source": [
    "# Load SLDS Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "51b7da2f",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 /data/users/eabe/hypernets/SLDS/TiDHy_SLDS/partial_obs/Orth_alpha_r2=5,dataset.ssm_params.partial_obs=True,dataset.ssm_params.partial_sup=False,dataset.ssm_params.seed=10,dataset.train.num_epochs=1500/config.yaml\n",
      "1 /data/users/eabe/hypernets/SLDS/TiDHy_SLDS/partial_obs/Orth_alpha_r2=5,dataset.ssm_params.partial_obs=True,dataset.ssm_params.partial_sup=False,dataset.ssm_params.seed=11,dataset.train.num_epochs=1500/config.yaml\n",
      "2 /data/users/eabe/hypernets/SLDS/TiDHy_SLDS/partial_obs/Orth_alpha_r2=5,dataset.ssm_params.partial_obs=True,dataset.ssm_params.partial_sup=False,dataset.ssm_params.seed=12,dataset.train.num_epochs=1500/config.yaml\n",
      "3 /data/users/eabe/hypernets/SLDS/TiDHy_SLDS/partial_obs/Orth_alpha_r2=5,dataset.ssm_params.partial_obs=True,dataset.ssm_params.partial_sup=False,dataset.ssm_params.seed=13,dataset.train.num_epochs=1500/config.yaml\n"
     ]
    }
   ],
   "source": [
    "dataset = 'SLDS'\n",
    "# version = 'r2_orth_long'\n",
    "version = 'partial_obs'\n",
    "base_dir = Path('/data/users/eabe/hypernets/{}/TiDHy_{}/{}'.format(dataset,dataset,version))\n",
    "configs = sorted(list(base_dir.rglob('*config.yaml'))[::2])\n",
    "fig_path = Path(f'/data/users/eabe/hypernets/SLDS/TiDHy_SLDS/{version}/Paper_Figs')\n",
    "fig_path.mkdir(parents=True,exist_ok=True)\n",
    "for n,conf in enumerate(configs):\n",
    "    print(n,conf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "97fe884c",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [],
   "source": [
    "n = 0\n",
    "cfg_path =configs[n]# Path('/data/users/eabe/hypernets/SLDS/DPC_SLDS/TestingNoTempLearning/mix_dim=15/config.yaml')\n",
    "default_model_config = '/home/eabe/Research/MyRepos/HyperNets/conf/dataset/model/default_model.yaml'\n",
    "cfg = load_cfg(cfg_path, default_model_config)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "280b7c65",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating Dataset: SLDS\n",
      "Setting seed: 10\n",
      "Setting seed: 10\n",
      "x Timescales: {'0': -0.025, '1': -0.25, '2': -0.1, '3': -0.5, '4': -0.01, '5': -0.75}, z Timescales: [0.975, 0.975, 0.975]\n",
      "Our inputs have shape: torch.Size([250, 200, 20])\n"
     ]
    }
   ],
   "source": [
    "data_dict, cfg = load_dataset(cfg)\n",
    "\n",
    "# ##### Convert to float tensors #####\n",
    "train_inputs = torch.tensor(data_dict['inputs_train']).float()\n",
    "test_inputs = torch.tensor(data_dict['inputs_test']).float()\n",
    "val_inputs = torch.tensor(data_dict['inputs_val']).float()\n",
    "\n",
    "input_dim = test_inputs.shape[-1]\n",
    "# test_inputs = test_inputs.unsqueeze(0)\n",
    "# test_inputs = stack_data(test_inputs,cfg.train.sequence_length,overlap=cfg.train.sequence_length//cfg.train.overlap_factor)\n",
    "test_inputs = test_inputs.reshape(-1, cfg.train.sequence_length, input_dim)\n",
    "val_inputs = val_inputs.reshape(-1, cfg.train.sequence_length, input_dim)\n",
    "# train_inputs = train_inputs.reshape(-1, cfg.train.sequence_length, input_dim)\n",
    "# cfg.model.input_dim = input_dim\n",
    "\n",
    "\n",
    "\n",
    "print(f'Our inputs have shape: {test_inputs.shape}')\n",
    "cfg.model.input_dim = input_dim\n",
    "test_dataset = torch.utils.data.TensorDataset(test_inputs)\n",
    "train_dataset = torch.utils.data.TensorDataset(train_inputs)\n",
    "val_dataset = torch.utils.data.TensorDataset(val_inputs)\n",
    "# dataloader_train = torch.utils.data.DataLoader(train_dataset,batch_size=train_inputs.shape[0],pin_memory=True,shuffle=False,drop_last=True)\n",
    "dataloader_test = torch.utils.data.DataLoader(test_dataset,batch_size=test_inputs.shape[0],pin_memory=True,shuffle=False,drop_last=True)\n",
    "# dataloader_val = torch.utils.data.DataLoader(val_dataset,batch_size=val_inputs.shape[0],shuffle=False,pin_memory=True,drop_last=True)\n",
    "# device = torch.device(\"cuda:{}\".formt(cfg.train['gpu']) if torch.cuda.is_available() else \"cpu\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9fce1a91",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded from 1496 epoch\n"
     ]
    }
   ],
   "source": [
    "##### Load weights and params #####\n",
    "rerecord = False\n",
    "cfg.model.batch_converge=False\n",
    "epoch = 1000\n",
    "model = TiDHy.TiDHy(cfg.model, device, show_progress=cfg.train.show_progress).to(device)\n",
    "# set_seed(42)\n",
    "load_path = cfg.paths.ckpt_dir/'best.pth.tar'\n",
    "# load_path = sorted(list(cfg.paths.ckpt_dir.rglob('last_{}.pth.tar'.format(epoch))))[0]\n",
    "data_load = torch.load(load_path,map_location=device)\n",
    "model.load_state_dict(data_load['state_dict'])\n",
    "model.to(device)\n",
    "print('Loaded from {} epoch'.format(data_load['epoch']))\n",
    "epoch = data_load['epoch']-1\n",
    "\n",
    "\n",
    "# result_dict = load_results(model, dataloader_test, data_dict, device, cfg, epoch, rerecord=rerecord)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ecd6b3a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAABACAYAAABsv8+/AAAAGHRFWHRUaXRsZQBmcm9tX2xpc3QgY29sb3JtYXBDL89FAAAAHnRFWHREZXNjcmlwdGlvbgBmcm9tX2xpc3QgY29sb3JtYXABtCnOAAAAMHRFWHRBdXRob3IATWF0cGxvdGxpYiB2My45LjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmdUdHMAAAAAMnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHYzLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZ3rS7CcAAAGFSURBVHic7dahTURRFEVRPmUgMLSAwSPGI7EUgCYEiUXQCMlIQj8QHAY5tPAUN5O9VgUnOWZvZxdPh5MjcXd5PT1h2e/5fnrCkt1uNz1h2cvP6/SEJfuvt+kJyx4+juf/5++r6QlLtseb6QnLDrf30xPWfL5PL1i2bdv0hGWn0wMAgP8nAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAE/QGGHBF/qpaioAAAAABJRU5ErkJggg==",
      "text/html": [
       "<div style=\"vertical-align: middle;\"><strong>from_list</strong> </div><div class=\"cmap\"><img alt=\"from_list colormap\" title=\"from_list\" style=\"border: 1px solid #555;\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAgAAAABACAYAAABsv8+/AAAAGHRFWHRUaXRsZQBmcm9tX2xpc3QgY29sb3JtYXBDL89FAAAAHnRFWHREZXNjcmlwdGlvbgBmcm9tX2xpc3QgY29sb3JtYXABtCnOAAAAMHRFWHRBdXRob3IATWF0cGxvdGxpYiB2My45LjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmdUdHMAAAAAMnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHYzLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZ3rS7CcAAAGFSURBVHic7dahTURRFEVRPmUgMLSAwSPGI7EUgCYEiUXQCMlIQj8QHAY5tPAUN5O9VgUnOWZvZxdPh5MjcXd5PT1h2e/5fnrCkt1uNz1h2cvP6/SEJfuvt+kJyx4+juf/5++r6QlLtseb6QnLDrf30xPWfL5PL1i2bdv0hGWn0wMAgP8nAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAECQAACBIAABAkAAAgSAAAQJAAAIAgAQAAQQIAAIIEAAAE/QGGHBF/qpaioAAAAABJRU5ErkJggg==\"></div><div style=\"vertical-align: middle; max-width: 514px; display: flex; justify-content: space-between;\"><div style=\"float: left;\"><div title=\"#1a237eff\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #1a237eff;\"></div> under</div><div style=\"margin: 0 auto; display: inline-block;\">bad <div title=\"#00000000\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #00000000;\"></div></div><div style=\"float: right;\">over <div title=\"#000000ff\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #000000ff;\"></div></div>"
      ],
      "text/plain": [
       "<matplotlib.colors.ListedColormap at 0x7c80d06e7730>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "fontsize=13\n",
    "\n",
    "clrs = np.array(['#1A237E','#7E57C2','#757575','#BDBDBD','#4CAF50','#FF9800','#795548','#FF4081','#00BCD4','#FF1744','#FFFFFF','#000000'])\n",
    "sys_clrs = ['#E3A19F','#E3BE53','#708090','#90CCA9','#B7522E','#B0E0E6','#A89AC2','#556B2F','#FF6F61','#87CEEB','#FFDAB9','#40E0D0']\n",
    "cmap_sys = ListedColormap(sys_clrs)\n",
    "clr_ind =[8,8,1,1,9,9]\n",
    "# clr2 = [sys_clrs[clr_ind[n]] for n in range(len(clr_ind))]\n",
    "clr_ind3 = [2,8,9]\n",
    "clr2b = [sys_clrs[clr_ind3[n]] for n in range(len(clr_ind3))]\n",
    "\n",
    "clrs_b = clrs[[0,1,2,9,4,6,7,8,11]]\n",
    "cmap = ListedColormap(clrs)\n",
    "# cmap_small = ListedColormap(clrs[:len(np.unique(full_state_z))])\n",
    "cmap_b = ListedColormap(clrs_b)\n",
    "cmap\n",
    "# cmap_b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09a5434c",
   "metadata": {},
   "source": [
    "# Save Multi Seq Len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d9cae1cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating Dataset: SLDS\n",
      "Setting seed: 10\n",
      "Setting seed: 10\n",
      "x Timescales: {'0': -0.025, '1': -0.25, '2': -0.1, '3': -0.5, '4': -0.01, '5': -0.75}, z Timescales: [0.975, 0.975, 0.975]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[100, 200, 500, 1000]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_len = [100,200,500,1000]\n",
    "\n",
    "cfg, result_dict = run_seq_len_model(seq_len, model, data_dict, device, 1500, cfg, rerun=False)\n",
    "\n",
    "data_dict, cfg = load_dataset(cfg)\n",
    "seq_len = sorted([int(el) for el in list(result_dict.keys())])\n",
    "seq_len"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2664017",
   "metadata": {},
   "source": [
    "## Load Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c1fa3122",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "states_x_test = data_dict['states_x_test']\n",
    "states_z_test = data_dict['states_z_test']\n",
    "# states_z_test = data_dict['states_z']\n",
    "ssm_params = cfg.dataset.ssm_params\n",
    "##### Set up combinatorics of timescales #####\n",
    "lst = list(itertools.product([0, 1], repeat=3))\n",
    "lst2 = list(itertools.product(['F', 'S'], repeat=3))\n",
    "full_state_z = np.zeros(ssm_params['time_bins_test'],dtype=int)\n",
    "# full_state_z = np.zeros(ssm_params['time_bins_train'],dtype=int)\n",
    "for n in range(len(lst)):\n",
    "    full_state_z[np.apply_along_axis(lambda x: np.all(x == lst[n]),0,states_z_test)] = n\n",
    "\n",
    "\n",
    "save_figs = False\n",
    "p=-1\n",
    "W = result_dict['{}'.format(seq_len[p])]['W'].reshape(-1,result_dict['{}'.format(seq_len[p])]['W'].shape[-1])\n",
    "# b = result_dict['b'].reshape(-1,result_dict['b'].shape[-1])\n",
    "I = result_dict['{}'.format(seq_len[p])]['I'].reshape(-1,result_dict['{}'.format(seq_len[p])]['I'].shape[-1])\n",
    "Ihat = result_dict['{}'.format(seq_len[p])]['I_hat'].reshape(-1,result_dict['{}'.format(seq_len[p])]['I_hat'].shape[-1])\n",
    "Ibar = result_dict['{}'.format(seq_len[p])]['I_bar'].reshape(-1,result_dict['{}'.format(seq_len[p])]['I_bar'].shape[-1])\n",
    "R_hat = result_dict['{}'.format(seq_len[p])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[p])]['R_hat'].shape[-1])\n",
    "R_bar = result_dict['{}'.format(seq_len[p])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[p])]['R_bar'].shape[-1])\n",
    "R2_hat = result_dict['{}'.format(seq_len[p])]['R2_hat'].reshape(-1,result_dict['{}'.format(seq_len[p])]['R2_hat'].shape[-1])\n",
    "# Ut = result_dict['Ut'].reshape(-1,result_dict['Ut'].shape[-2],result_dict['Ut'].shape[-1])\n",
    "# ##### Plot dynamic matrices #####\n",
    "if cfg.model.low_rank_temp:\n",
    "    Uk = torch.bmm(model.temporal.unsqueeze(-1),model.temporal.unsqueeze(1)).data.cpu().detach()\n",
    "else:\n",
    "    Uk = model.temporal.data.cpu().detach().reshape(model.mix_dim,model.r_dim,model.r_dim)\n",
    "    U_t = torch.matmul(torch.Tensor(W[:,None,:]), model.temporal.unsqueeze(0).cpu().detach()).reshape(-1, model.r_dim, model.r_dim).numpy()\n",
    "As = np.stack([v for v in data_dict['As'].values()])\n",
    "bs = np.stack([v for v in data_dict['bs'].values()])\n",
    "nfig = 0\n",
    "fontsize=13\n",
    "# t = 0; dt = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "770f503d",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "from ssm.util import random_rotation, find_permutation\n",
    "inputs_train_SLDS=data_dict['inputs_train']\n",
    "inputs_test_SLDS=data_dict['inputs_test']\n",
    "seed = cfg.dataset.ssm_params['seed']\n",
    "# SLDS_path = Path('/data/users/eabe/hypernets/SLDS/TiDHy_SLDS/L1ShortWin/L1_alpha=0.001,dataset.ssm_params.seed=10,dataset.train.sequence_length=200')\n",
    "SLDS_path = cfg.paths.log_dir#/'SSM/DPC_SSM/Benchmark/dataset.ssm_params.seed={}/'.format(seed)\n",
    "N = inputs_train_SLDS.shape[-1]\n",
    "K = len(np.unique(full_state_z))\n",
    "D = data_dict['states_x_test'].shape[-1]\n",
    "with open(SLDS_path/'ssm_slds_test_full_{}D_{}K_{}seed.pickle'.format(D,K,seed), 'rb') as handle:\n",
    "# with open(cfg.paths.data_dir/'ssm_rslds_test.pickle', 'rb') as handle:\n",
    "    slds = pickle.load(handle)\n",
    "    posterior = pickle.load(handle)\n",
    "    SLDS_latents = pickle.load(handle)\n",
    "    SLDS_states = pickle.load(handle)\n",
    "    SLDS_emission = pickle.load(handle)\n",
    "\n",
    "with open(SLDS_path/'ssm_rslds_test_full_{}D_{}K_{}seed.pickle'.format(D,K,seed), 'rb') as handle:\n",
    "# with open(cfg.paths.data_dir/'ssm_rslds_test.pickle', 'rb') as handle:\n",
    "    slds = pickle.load(handle)\n",
    "    posterior = pickle.load(handle)\n",
    "    rSLDS_latents = pickle.load(handle)\n",
    "    rSLDS_states = pickle.load(handle)\n",
    "    rSLDS_emission = pickle.load(handle)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c537481f",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "1"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2_hat 0.80072\n",
      "W 0.6328\n",
      "R_bar 0.46696\n",
      "R_hat 0.48992\n",
      "I 0.46936\n",
      "SLDS 0.43768\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import RidgeClassifier,LogisticRegression, RidgeClassifierCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "# from statsmodels.tsa.api import VAR\n",
    "\n",
    "nani = full_state_z.shape[0]\n",
    "ts=-1\n",
    "reg_variables = [\n",
    "    result_dict['{}'.format(seq_len[ts])]['R2_hat'],\n",
    "    result_dict['{}'.format(seq_len[ts])]['W'],\n",
    "    result_dict['{}'.format(seq_len[ts])]['R_bar'],\n",
    "    result_dict['{}'.format(seq_len[ts])]['R_hat'],\n",
    "    result_dict['{}'.format(seq_len[ts])]['I'],\n",
    "    SLDS_latents,]\n",
    "\n",
    "labels = ['R2_hat','W','R_bar','R_hat','I','SLDS']\n",
    "max_acc = 0\n",
    "tr_batch_size = 40\n",
    "batch_size = 10\n",
    "for k,reg_vars in enumerate(reg_variables):\n",
    "    X_train, X_test, y_train, y_test = train_test_split(reg_vars.reshape(-1,reg_vars.shape[-1]), full_state_z.reshape(-1), test_size=0.25, random_state=42)\n",
    "    neigh = KNeighborsClassifier(n_neighbors=3,n_jobs=-1)\n",
    "    neigh.fit(X_train, y_train)\n",
    "    scores = neigh.score(X_test, y_test)\n",
    "    print(labels[k],scores)\n",
    "    if (scores > max_acc) & (labels[k] != 'I'):\n",
    "        y_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "        max_acc = scores\n",
    "        best_reg_vars = reg_vars\n",
    "        best_label = labels[k]\n",
    "        best_pred = y_pred\n",
    "\n",
    "state_compare = np.stack([rSLDS_states, SLDS_states,best_pred,full_state_z],axis=0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d29b9e60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "comp 0, cc: 1.0, ang: 1.69, ang_x:61.1, ang_r:1.2e+02\n",
      "comp 1, cc: 0.958, ang: 16.6, ang_x:1.05e+02, ang_r:1.08e+02\n",
      "comp 0, cc: 0.998, ang: 3.16, ang_x:41.2, ang_r:1.35e+02\n",
      "comp 1, cc: 0.488, ang: 60.8, ang_x:48.5, ang_r:82.0\n",
      "comp 0, cc: 0.997, ang: 4.23, ang_x:36.0, ang_r:1.04e+02\n",
      "comp 1, cc: 0.959, ang: 16.5, ang_x:58.4, ang_r:98.7\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x550 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.cross_decomposition import CCA\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "n_comps=ssm_params['latent_dim']\n",
    "t=1500; dt=200\n",
    "    \n",
    "fig = plt.figure(constrained_layout=True, figsize=(7,5.5))\n",
    "gs0 = gridspec.GridSpec(nrows=5,ncols=4, figure=fig, wspace=.45,hspace=.2)\n",
    "\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(nrows=6,ncols=1,subplot_spec=gs0[:,:2],wspace=.1,hspace=.2)\n",
    "# gs01 = gridspec.GridSpecFromSubplotSpec(3,1, subplot_spec=gs0[0:,:1],wspace=.05,hspace=.8)\n",
    "axs = np.array([fig.add_subplot(gs00[:-3,0]),\n",
    "                fig.add_subplot(gs00[-3:-2,0]),\n",
    "                fig.add_subplot(gs00[-2:,0]),\n",
    "                fig.add_subplot(gs0[:3,2:]),\n",
    "                fig.add_subplot(gs0[3:,2:])])\n",
    "axs[4].sharex(axs[3])\n",
    "ts = -1\n",
    "##### Pannel a #####\n",
    "I = result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1])\n",
    "Ihat = result_dict['{}'.format(seq_len[ts])]['I_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1])\n",
    "# fig,axs = plt.subplots(1,2,figsize=(5,3),sharey=True,gridspec_kw={'wspace':.15,'width_ratios':[2,1]})\n",
    "ax = axs[0]\n",
    "spacing = 1\n",
    "xrange = 100\n",
    "cmap2,norm = map_discrete_cbar(cmap_b,len(np.unique(full_state_z)))\n",
    "linestyle =  (0, (5, 1))#(0, (5, 5))\n",
    "hlines_I,hlines_Ihat = [],[]\n",
    "for n in range(I.shape[-1]):\n",
    "    mean_centered_I = I[t:t+dt,n] - np.mean(I[t:t+dt,n],axis=0)\n",
    "    ax.plot(mean_centered_I + n/spacing,color='k', lw=2,zorder=1,label='Data')\n",
    "    hlines_I.append(np.mean(mean_centered_I + n/spacing,axis=0))\n",
    "    mean_centered_Ihat = Ihat[t:t+dt,n] - np.mean(Ihat[t:t+dt,n],axis=0)\n",
    "    ax.plot(mean_centered_Ihat + n/spacing, linestyle=linestyle, color='r', lw=1,zorder=2,label='Pred')\n",
    "    hlines_Ihat.append(np.mean(mean_centered_Ihat + n/spacing,axis=0))\n",
    "\n",
    "# ax.set_yticks(hlines_I)\n",
    "ax.set_yticks([])\n",
    "# ax.set_yticklabels(np.arange(1,len(hlines_I)+1),fontsize=fontsize-2)\n",
    "ax.set_ylabel('observations',fontsize=fontsize)\n",
    "ax.set_xticks(np.arange(0,dt+xrange,xrange))\n",
    "ax.set_xticklabels(np.arange(0,dt+xrange,xrange),fontsize=fontsize-2)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "\n",
    "##### Pannel c #####\n",
    "ax = axs[3]\n",
    "count=0\n",
    "acc_slds = accuracy_score(full_state_z, SLDS_states)\n",
    "acc_rslds = accuracy_score(full_state_z, rSLDS_states)\n",
    "acc_TiDHy = accuracy_score(full_state_z, y_pred)\n",
    "spacing = .5\n",
    "\n",
    "hlines_x,hlines_Rhat = [],[]\n",
    "for p in range(ssm_params['Nlds']):\n",
    "    # states_x_cca = states_x_train[:,(ssm_params['latent_dim']*(p)):(p+1)*ssm_params['latent_dim']]\n",
    "    states_x_cca = states_x_test[:,(ssm_params['latent_dim']*(p)):(p+1)*ssm_params['latent_dim']]\n",
    "    # states_x_cca = states_x_test[:,p:p+1]\n",
    "    cca = CCA(n_components=ssm_params['latent_dim'],max_iter=1000)\n",
    "    X_c,Y_c = cca.fit_transform(states_x_cca,R_hat)\n",
    "    cca_coefficient = np.corrcoef(X_c.T, Y_c.T).diagonal(offset=n_comps)\n",
    "    x_w = cca.x_weights_\n",
    "    y_w = cca.y_weights_\n",
    "    cca_angles = [np.rad2deg(angle_between(X_c[:,n],Y_c[:,n])) for n in range(n_comps)]\n",
    "    cca_angles_x = [np.rad2deg(angle_between(X_c[:,n],states_x_cca[:,n])) for n in range(n_comps)]\n",
    "    cca_angles_r = [np.rad2deg(angle_between(Y_c[:,n],R_hat[:,n])) for n in range(n_comps)]\n",
    "    for n in range(n_comps):\n",
    "        print('comp {}, cc: {:.03}, ang: {:.03}, ang_x:{:.03}, ang_r:{:.03}'.format(n,cca_coefficient[n],cca_angles[n],cca_angles_x[n],cca_angles_r[n]))\n",
    "\n",
    "    for i in range(X_c.shape[-1]):\n",
    "        mean_centered_x = X_c[t:t+dt,i] - np.mean(X_c[t:t+dt,i],axis=0)\n",
    "        mean_centered_x=mean_centered_x/(np.max(np.abs(mean_centered_x)))\n",
    "        ax.plot(np.arange(0,dt),mean_centered_x + count/spacing,color='k', lw=2,zorder=1)\n",
    "        hlines_x.append(np.mean(mean_centered_x + count/spacing,axis=0))\n",
    "        mean_centered_Rhat = Y_c[t:t+dt,i] - np.mean(Y_c[t:t+dt,i],axis=0)\n",
    "        mean_centered_Rhat=mean_centered_Rhat/(np.max(np.abs(mean_centered_Rhat)))\n",
    "        ax.plot(np.arange(0,dt),mean_centered_Rhat + count/spacing,linestyle=linestyle,color='r', lw=1.5,zorder=2,label='$\\hat{{r}}_{{{}}}$={:.02}'.format(n,cca_coefficient[n]),alpha=1)\n",
    "        hlines_Rhat.append(np.mean(mean_centered_Rhat + count/spacing,axis=0))\n",
    "        ax.text(x=dt+15,y=hlines_x[count],s='cc = {:.02}'.format(cca_coefficient[i]),fontsize=fontsize-2)\n",
    "        count += 1\n",
    "    ax.set_yticks(hlines_x) \n",
    "    ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "    # ax.set_xlabel('Timesteps',fontsize=fontsize)\n",
    "    ax.set_ylabel('latent variables',fontsize=fontsize)\n",
    "# ax.set_xticks([])\n",
    "ax.set_xticks(np.arange(0,dt+200,200))\n",
    "ax.set_xticklabels(np.arange(0,dt+200,200),fontsize=fontsize-2)\n",
    "ax.set_xlabel('timesteps', fontsize=fontsize)\n",
    "# X,Y = np.meshgrid(np.arange(0,dt),np.arange(-1,2*6))\n",
    "# im = ax.pcolormesh(X,Y,np.tile(full_state_z[None,t:t+dt],(2*6+1,1)),cmap=cmap,norm=norm,alpha=.5,rasterized=True,zorder=-1)\n",
    "ax.legend(['data','pred'],frameon=False,fontsize=fontsize,loc='upper right',bbox_to_anchor=(1.1,1.1),labelcolor='linecolor',handlelength=0,handleheight=0,ncols=2,columnspacing=.1)\n",
    "\n",
    "##### Pannel b #####\n",
    "ax = axs[1]\n",
    "dts = 1/len(np.unique(full_state_z))\n",
    "y_ranges=np.repeat([[0,1]],3,axis=0)\n",
    "timescales_As = 1/np.abs(np.real(np.log(np.linalg.eigvals(As)))[:,:,0].reshape(-1))\n",
    "# timescales_As = 1/np.abs(np.log(np.real(np.linalg.eigvals(As)))[:,:,0].reshape(-1))\n",
    "evals_As = np.linalg.eigvals(As)[:,:,0].reshape(-1)\n",
    "R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "Uhat_all = []\n",
    "for state in range(len(np.unique(full_state_z))):\n",
    "    rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "    Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "    Uhat_all.append(Uhat_0)\n",
    "    \n",
    "# for p in range(ssm_params.Nlds):\n",
    "#     for state in range(ssm_params.n_disc_states):\n",
    "#         rhat2 = R_hat[np.where(states_z_test[p]==state)[0],:]\n",
    "#         Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "#         Uhat_all.append(Uhat_0)\n",
    "        \n",
    "Uhat_all = np.stack(Uhat_all)\n",
    "evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "timescales = 1/np.abs(np.real(np.log(evals_Uhat_all)))\n",
    "# timescales = 1/np.abs(np.log(np.real(evals_Uhat_all)))\n",
    "ax.scatter(x=timescales,y=np.abs(evals_Uhat_all),\n",
    "            c='k',s=40,alpha=.5,edgecolor='None')\n",
    "for n in range(len(timescales_As)):\n",
    "    ax.axvline(x=timescales_As[n],c=sys_clrs[clr_ind[n]])\n",
    "    ax.scatter(x=timescales_As[n],y=np.abs(evals_As[n]),\n",
    "            c=sys_clrs[clr_ind[n]],s=40,alpha=1,edgecolor='None')\n",
    "ax.set_xscale('symlog',linthresh=.1)\n",
    "ax.set_yticks([0,.5,1])\n",
    "ax.set_ylim(0,1.1)\n",
    "# ax.set_yticks([np.diff(y_ranges)[0,0]/2 + q*dts for q in range(len(np.unique(full_state_z)))])\n",
    "# ax.set_yticklabels([''.join(lst2[n]) for n in range(len(lst2))],fontsize=fontsize-2)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "ax.set_ylabel('|$\\lambda$|',fontsize=fontsize)\n",
    "y = 1\n",
    "dy = 0.15\n",
    "ax.annotate('system 1', xy=(.01,y),xycoords='axes fraction',color=sys_clrs[clr_ind[0]],fontsize=fontsize-3.5)\n",
    "ax.annotate('system 2', xy=(.01,y-dy),xycoords='axes fraction',color=sys_clrs[clr_ind[2]],fontsize=fontsize-3.5)\n",
    "ax.annotate('system 3', xy=(.01,y-2*dy),xycoords='axes fraction',color=sys_clrs[clr_ind[4]],fontsize=fontsize-3.5)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.set_xlabel('timescales',fontsize=fontsize,labelpad=-1)\n",
    "\n",
    "######### Accuracy and reconstruction error #########\n",
    "ax = axs[2]\n",
    "Input_Errors_SLDS = np.abs(inputs_test_SLDS-SLDS_emission)\n",
    "Input_Errors_rSLDS = np.abs(inputs_test_SLDS-rSLDS_emission)\n",
    "Input_Errors = np.abs(I-result_dict['{}'.format(seq_len[ts])]['I_hat'])\n",
    "err_slds  = 100*(1-accuracy_score(full_state_z, SLDS_states))\n",
    "err_rslds = 100*(1-accuracy_score(full_state_z, rSLDS_states))\n",
    "err_TiDHy = 100*(1-accuracy_score(full_state_z, y_pred))\n",
    "ax.scatter(x=np.mean(Input_Errors_SLDS),y=err_slds, s=25, c=clrs[2],label='SLDS')\n",
    "ax.errorbar(x=np.mean(Input_Errors_SLDS),y=err_slds, ecolor=clrs[2],xerr=np.std(Input_Errors_SLDS))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "ax.scatter(x=np.mean(Input_Errors_rSLDS),y=err_rslds, s=25,c=clrs[6],label='rSLDS')\n",
    "ax.errorbar(x=np.mean(Input_Errors_rSLDS),y=err_rslds, ecolor=clrs[6],xerr=np.std(Input_Errors_rSLDS))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "ax.scatter(x=np.mean(Input_Errors),y=err_TiDHy, s=25, c=clrs[1],label='TiDHy')\n",
    "ax.errorbar(x=np.mean(Input_Errors),y=err_TiDHy, ecolor=clrs[1],xerr=np.std(Input_Errors))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "ax.set_yticks([0,25,50,75,100])\n",
    "ax.set_xlabel('reconstruction error',fontsize=fontsize)\n",
    "ax.set_ylabel('dyn. % error',fontsize=fontsize)\n",
    "ax.ticklabel_format(axis='x', style='sci', scilimits=(0,0),useLocale=True)\n",
    "ax.legend(frameon=False,fontsize=fontsize-3,loc='upper right',bbox_to_anchor=(1.1,1.1),labelcolor='linecolor',handlelength=0,handleheight=0,ncols=1,columnspacing=.1)\n",
    "\n",
    "##### Pannel d #####\n",
    "ax = axs[4]\n",
    "ylabels_states = ['rSLDS \\n {:02}%'.format(int(np.round(acc_rslds*100))),\n",
    "                  'SLDS \\n {:02}%'.format(int(np.round(acc_slds*100))),\n",
    "                  'TiDHy \\n {:02}%'.format(int(np.round(acc_TiDHy*100))),\n",
    "                  'True']\n",
    "im = ax.pcolormesh(state_compare[:,t:t+dt],cmap=cmap2,norm=norm,alpha=.5,rasterized=True)\n",
    "ax.set_xticks(np.arange(0,dt+xrange,xrange))\n",
    "ax.set_xticklabels(np.arange(0,dt+xrange,xrange),fontsize=fontsize-2)\n",
    "ax.set_yticks(np.arange(.5,4,1))\n",
    "ax.set_yticklabels(ylabels_states,fontsize=fontsize-2)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "\n",
    "cbar = fig.colorbar(im,ax=axs[-1],aspect=10, pad=-.2)\n",
    "\n",
    "cbar.set_ticks(np.arange(0,len(np.unique(full_state_z)),1))\n",
    "cbar.set_ticklabels([''.join(lst2[n]) for n in np.arange(len(lst2)-1,-1,-1)],fontsize=fontsize)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")\n",
    "# fig.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'Benchmark_Compare3.pdf',dpi=300)\n",
    "fig.savefig(fig_path/'{}_Fig2_V2.pdf'.format(nfig),dpi=300, transparent=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "28f56611",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2_hat 0.84072\n",
      "R2_hat 0.84128\n",
      "R2_hat 0.804\n",
      "R2_hat 0.80072\n"
     ]
    }
   ],
   "source": [
    "\n",
    "nani = full_state_z.shape[0]\n",
    "ts=1\n",
    "best_pred_all = []\n",
    "acc_ssm = accuracy_score(full_state_z, SLDS_states)\n",
    "acc_TiDHy_all = []\n",
    "for ts in range(len(seq_len)):\n",
    "    reg_variables = [\n",
    "        # np.concatenate([result_dict['{}'.format(seq_len[ts])]['R2_hat'],result_dict['{}'.format(seq_len[ts])]['W']],axis=-1)\n",
    "        result_dict['{}'.format(seq_len[ts])]['R2_hat'],\n",
    "        # q_lem_x,\n",
    "        ]\n",
    "\n",
    "    labels = ['R2_hat']\n",
    "    # reg_variables = W\n",
    "    max_acc = 0\n",
    "    for k,reg_vars in enumerate(reg_variables):\n",
    "        X_train, X_test, y_train, y_test = train_test_split(reg_vars.reshape(-1,reg_vars.shape[-1]), full_state_z.reshape(-1), test_size=0.25, random_state=42)\n",
    "        neigh = KNeighborsClassifier(n_neighbors=3,n_jobs=-1)\n",
    "        neigh.fit(X_train, y_train)\n",
    "        scores = neigh.score(X_test, y_test)\n",
    "        y_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "        print(labels[k],scores)\n",
    "        acc_TiDHy = accuracy_score(full_state_z, y_pred)\n",
    "        acc_TiDHy_all.append(acc_TiDHy)\n",
    "        best_pred_all.append(y_pred)\n",
    "\n",
    "state_compare = np.concatenate([SLDS_states[None,:],np.stack(best_pred_all),full_state_z[None,:]],axis=0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dbac2ec",
   "metadata": {},
   "source": [
    "## Load multi-seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6d49857e",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_len = [100,200,500,1000]\n",
    "\n",
    "result_dict_all = {}\n",
    "for n in range(len(configs)):\n",
    "    cfg_path =configs[n]# Path('/data/users/eabe/hypernets/SLDS/DPC_SLDS/TestingNoTempLearning/mix_dim=15/config.yaml')\n",
    "    default_model_config = '/home/eabe/Research/MyRepos/HyperNets/conf/dataset/model/default_model.yaml'\n",
    "    cfg = load_cfg(cfg_path, default_model_config)\n",
    "    cfg, result_dict = run_seq_len_model(seq_len, model, data_dict, device, 1500, cfg, rerun=False)\n",
    "    result_dict_all['seed_{}'.format(cfg.dataset.ssm_params.seed)] = result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d3ae2fac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['As', 'I', 'I_bar', 'I_hat', 'R2_hat', 'R_bar', 'R_hat', 'Ut', 'W', 'bs', 'spatial_loss_rbar', 'spatial_loss_rhat', 'states_x_test', 'states_x_train', 'states_z_test', 'states_z_train', 'temp_loss'])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default values\n",
    "seeds = np.arange(10,10+len(configs))\n",
    "seed = 10\n",
    "ts = 200\n",
    "\n",
    "##### Set up combinatorics of timescales #####\n",
    "ssm_params = cfg.dataset.ssm_params\n",
    "lst = list(itertools.product([0, 1], repeat=3))\n",
    "lst2 = list(itertools.product(['F', 'S'], repeat=3))\n",
    "full_state_z = np.zeros((len(seeds),ssm_params['time_bins_test']),dtype=int)\n",
    "# full_state_z = np.zeros(ssm_params['time_bins_train'],dtype=int)\n",
    "for i, seed in enumerate(seeds):\n",
    "    for n in range(len(lst)):\n",
    "        full_state_z[i,np.apply_along_axis(lambda x: np.all(x == lst[n]),0,result_dict_all[f'seed_{seed}'][f'{ts}']['states_z_test'])] = n\n",
    "    \n",
    "I_all = np.stack([result_dict_all[f'seed_{seed}'][f'{ts}']['I'] for seed in seeds])\n",
    "I_hat_all = np.stack([result_dict_all[f'seed_{seed}'][f'{ts}']['I_hat'] for seed in seeds])\n",
    "R2_hat_all = np.stack([np.stack([result_dict_all[f'seed_{seed}'][f'{ts}']['R2_hat'] for ts in seq_len])for seed in seeds])  # (n_seeds, Time, Z_dim)\n",
    "R_bar_all = np.stack([np.stack([result_dict_all[f'seed_{seed}'][f'{ts}']['R_bar'] for ts in seq_len]) for seed in seeds])   # (n_seeds, TempWinN, Time, r2_dim)\n",
    "R_hat_all = np.stack([np.stack([result_dict_all[f'seed_{seed}'][f'{ts}']['R_hat'] for ts in seq_len]) for seed in seeds])   # (n_seeds, TempWinN, Time, r_dim)\n",
    "W_all = np.stack([np.stack([result_dict_all[f'seed_{seed}'][f'{ts}']['W'] for ts in seq_len]) for seed in seeds])           # (n_seeds, TempWinN, Time, r_dim)\n",
    "As_all = np.stack([np.stack([v for v in result_dict_all[f'seed_{seed}'][f'{ts}']['As'].values()]) for seed in seeds])\n",
    "result_dict_all[f'seed_{seed}'][f'{ts}'].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5fac0f61",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "from ssm.util import random_rotation, find_permutation\n",
    "inputs_train_SLDS=data_dict['inputs_train']\n",
    "inputs_test_SLDS=data_dict['inputs_test']\n",
    "seed = cfg.dataset.ssm_params['seed']\n",
    "TotalTime = cfg.dataset.ssm_params.time_bins_test\n",
    "# SLDS_path = Path('/data/users/eabe/hypernets/SLDS/TiDHy_SLDS/L1ShortWin/L1_alpha=0.001,dataset.ssm_params.seed=10,dataset.train.sequence_length=200')\n",
    "N = inputs_train_SLDS.shape[-1]\n",
    "K = len(np.unique(full_state_z))\n",
    "D = data_dict['states_x_test'].shape[-1]\n",
    "SLDS_latents = np.zeros((len(seeds),TotalTime,D))\n",
    "SLDS_states = np.zeros((len(seeds),TotalTime))\n",
    "SLDS_emission = np.zeros((len(seeds),TotalTime,N))\n",
    "rSLDS_latents = np.zeros((len(seeds),TotalTime,D))\n",
    "rSLDS_states = np.zeros((len(seeds),TotalTime))\n",
    "rSLDS_emission = np.zeros((len(seeds),TotalTime,N))\n",
    "for k, seed in enumerate(seeds):\n",
    "    SLDS_path = configs[k].parent#/'SSM/DPC_SSM/Benchmark/dataset.ssm_params.seed={}/'.format(seed)\n",
    "    with open(SLDS_path/'ssm_slds_test_full_{}D_{}K_{}seed.pickle'.format(D,K,seed), 'rb') as handle:\n",
    "    # with open(cfg.paths.data_dir/'ssm_rslds_test.pickle', 'rb') as handle:\n",
    "        slds = pickle.load(handle)\n",
    "        posterior = pickle.load(handle)\n",
    "        SLDS_latents[k] = pickle.load(handle)\n",
    "        SLDS_states[k] = pickle.load(handle)\n",
    "        SLDS_emission[k] = pickle.load(handle)\n",
    "\n",
    "    with open(SLDS_path/'ssm_rslds_test_full_{}D_{}K_{}seed.pickle'.format(D,K,seed), 'rb') as handle:\n",
    "    # with open(cfg.paths.data_dir/'ssm_rslds_test.pickle', 'rb') as handle:\n",
    "        slds = pickle.load(handle)\n",
    "        posterior = pickle.load(handle)\n",
    "        rSLDS_latents[k] = pickle.load(handle)\n",
    "        rSLDS_states[k] = pickle.load(handle)\n",
    "        rSLDS_emission[k] = pickle.load(handle)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6221e84e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 100 0.84072\n",
      "10 200 0.84128\n",
      "10 500 0.804\n",
      "10 1000 0.80072\n",
      "11 100 0.79784\n",
      "11 200 0.79472\n",
      "11 500 0.74128\n",
      "11 1000 0.70032\n",
      "12 100 0.79336\n",
      "12 200 0.75032\n",
      "12 500 0.69784\n",
      "12 1000 0.70504\n",
      "13 100 0.82632\n",
      "13 200 0.814\n",
      "13 500 0.78536\n",
      "13 1000 0.7852\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import RidgeClassifier,LogisticRegression, RidgeClassifierCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "# from statsmodels.tsa.api import VAR\n",
    "\n",
    "nani = full_state_z.shape[0]\n",
    "ts=-1\n",
    "\n",
    "labels = seeds\n",
    "max_acc = 0\n",
    "tr_batch_size = 40\n",
    "batch_size = 10\n",
    "scores_all = []\n",
    "pred_all = np.zeros((len(seeds),len(seq_len),cfg.dataset.ssm_params.time_bins_test))\n",
    "for k in range(len(seeds)):\n",
    "    for ts in range(len(seq_len)):\n",
    "        X_train, X_test, y_train, y_test = train_test_split(R2_hat_all[k,ts], full_state_z[k].reshape(-1), test_size=0.25, random_state=42)\n",
    "        neigh = KNeighborsClassifier(n_neighbors=3,n_jobs=-1)\n",
    "        neigh.fit(X_train, y_train)\n",
    "        scores = neigh.score(X_test, y_test)\n",
    "        y_pred = neigh.predict(R2_hat_all[k,ts])\n",
    "        pred_all[k,ts] = y_pred\n",
    "        scores_all.append(accuracy_score(full_state_z[k].reshape(-1),y_pred))\n",
    "        print(labels[k],seq_len[ts],scores)\n",
    "        if (scores > max_acc) & (labels[k] != 'I'):\n",
    "            max_acc = scores\n",
    "            best_label = k\n",
    "            best_pred = y_pred\n",
    "\n",
    "# state_compare = np.stack([rSLDS_states, SLDS_states,best_pred,full_state_z[best_label]],axis=0)\n",
    "\n",
    "scores_all = np.stack(scores_all).reshape(len(seeds),len(seq_len))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "a74e7ea9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((4, 4, 50000, 20), (4, 50000, 20), (4, 50000, 20))"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input_Errors_SLDS = (I_all[k]-SLDS_emission[k])\n",
    "Input_Errors_SLDS = np.stack([np.abs(I_all[k]-SLDS_emission[k]) for k in range(len(seeds))])\n",
    "\n",
    "Input_Errors_rSLDS = np.stack([np.abs(I_all[k]-rSLDS_emission[k]) for k in range(len(seeds))])\n",
    "\n",
    "Input_Errors = np.stack([np.stack([np.abs(I_all[seed]-I_hat_all[ts,seed]) for ts in range(len(seq_len))]) for seed in range(len(seeds))])\n",
    "\n",
    "Input_Errors.shape, Input_Errors_SLDS.shape, Input_Errors_rSLDS.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "203008df",
   "metadata": {},
   "outputs": [],
   "source": [
    "I_hat_all = np.stack([np.stack([result_dict_all[f'seed_{seed}'][f'{ts}']['I_hat'] for ts in seq_len]) for seed in seeds])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "424bfb99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((4, 50000, 20), (4, 4, 50000, 20))"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I_all.shape, I_hat_all.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "4dad99dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'reconstruction error')"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "R_diff = np.stack([np.mean(np.abs(R_hat_all[seed,1]-R_hat_all[seed,:]),axis=(-2,-1)) for seed in range(len(seeds))])\n",
    "\n",
    "fig,axs = plt.subplots(1,1,figsize=(3,3))\n",
    "ax = axs\n",
    "ax.boxplot(R_diff,showfliers=False)\n",
    "ax.set_xticklabels(seq_len)\n",
    "ax.set_xlabel('sequence length (T)')\n",
    "ax.set_ylabel('reconstruction error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "c8912cb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'reconstruction error')"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,axs = plt.subplots(1,1,figsize=(3,3))\n",
    "ax = axs\n",
    "ax.boxplot(np.mean(Input_Errors,axis=(-2,-1)),showfliers=False)\n",
    "ax.set_xticklabels(seq_len)\n",
    "ax.set_xlabel('sequence length (T)')\n",
    "ax.set_ylabel('reconstruction error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "e95c4380",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x716e401ab5e0>"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,1,figsize=(5,5))\n",
    "ax = axs\n",
    "lim0=0; lim1=1; hbins=.005\n",
    "for ts in range(len(seq_len)):\n",
    "    count,edges = np.histogram(Input_Errors[:,ts],bins=np.arange(lim0,lim1,hbins))\n",
    "    edges_mid = np.array([(edges[i]+edges[i+1])/2 for i in range(len(edges)-1)])\n",
    "    ax.bar(edges_mid, count/np.size(Input_Errors[:,ts]),color=clrs_b[ts],width=hbins, alpha=.5,zorder=1,label='TiDHy')\n",
    "\n",
    "# count,edges = np.histogram(Input_Errors_SLDS,bins=np.arange(lim0,lim1,hbins))\n",
    "# edges_mid = np.array([(edges[i]+edges[i+1])/2 for i in range(len(edges)-1)])\n",
    "# ax.bar(edges_mid, count/np.size(Input_Errors_SLDS),color=clrs[2],width=hbins, alpha=.75,zorder=1,label='SLDS')\n",
    "\n",
    "ax.set_xticks(np.arange(0,.25,.05))\n",
    "# ax.set_yticks([])\n",
    "ax.legend(frameon=False,fontsize=fontsize-2,loc='upper right',bbox_to_anchor=(.9,.9),labelcolor='linecolor',handlelength=0,handleheight=0,ncols=1,columnspacing=.1)\n",
    "# count,edges = np.histogram(Input_Errors,bins=np.arange(lim0,lim1,hbins))\n",
    "# edges_mid = np.array([(edges[i]+edges[i+1])/2 for i in range(len(edges)-1)])\n",
    "# ax.bar(edges_mid, count/len(Input_Errors),color=clrs_b[1],width=hbins, alpha=.5,zorder=1,label='data')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1f817574",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(constrained_layout=True, figsize=(8,6))\n",
    "gs0 = gridspec.GridSpec(nrows=4,ncols=2, figure=fig, wspace=.15,hspace=.2)\n",
    "axs = np.array([fig.add_subplot(gs0[:2,0]),fig.add_subplot(gs0[2:,0]),fig.add_subplot(gs0[:2,1]),fig.add_subplot(gs0[2:,1])])\n",
    "t=1500; dt=1000\n",
    "# seq_len=[100,200,500]\n",
    "ts = 1\n",
    "Input_Errors_SLDS = (I_all[k]-SLDS_emission[k])\n",
    "ax = axs[-1]\n",
    "Input_Errors_SLDS = np.mean([np.abs(I_all[k]-SLDS_emission[k]) for k in range(len(seeds))],axis=-1)\n",
    "Input_Errors_rSLDS = np.mean([np.abs(I_all[k]-rSLDS_emission[k]) for k in range(len(seeds))],axis=-1)\n",
    "err_slds  = np.mean([100*(1-accuracy_score(full_state_z[k], SLDS_states[k])) for k in range(len(seeds))])\n",
    "err_rslds = np.mean([100*(1-accuracy_score(full_state_z[k], rSLDS_states[k])) for k in range(len(seeds))])\n",
    "for ts in range(len(seq_len)):\n",
    "    Input_Errors =np.stack([np.abs(I_all[seed,ts]-I_hat_all[seed,ts]) for seed in range(len(seeds))])\n",
    "    err_TiDHy = np.mean([100*(1-accuracy_score(full_state_z[k], pred_all[k,ts])) for k in range(len(seeds))])\n",
    "    ax.scatter(x=np.mean(Input_Errors),y=err_TiDHy, s=25, c=clrs_b[ts],label='TiDHy')\n",
    "    ax.errorbar(x=np.mean(Input_Errors),y=err_TiDHy, ecolor=clrs_b[ts],xerr=np.mean(np.std(Input_Errors,axis=-1)),yerr=np.mean(np.std(Input_Errors,axis=0)))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "\n",
    "ax.scatter(x=np.mean(Input_Errors_SLDS),y=err_slds, s=25, c=clrs[2],label='SLDS')\n",
    "ax.errorbar(x=np.mean(Input_Errors_SLDS),y=err_slds, ecolor=clrs[2],xerr=np.std(Input_Errors_SLDS))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "ax.scatter(x=np.mean(Input_Errors_rSLDS),y=np.mean(err_rslds), s=25,c=clrs[6],label='rSLDS')\n",
    "ax.errorbar(x=np.mean(Input_Errors_rSLDS),y=np.mean(err_rslds), ecolor=clrs[6],xerr=np.std(Input_Errors_rSLDS))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "ax.set_yticks([0,25,50,75,100])\n",
    "ax.set_xlabel('reconstruction error',fontsize=fontsize)\n",
    "ax.set_ylabel('dyn. % error',fontsize=fontsize)\n",
    "ax.ticklabel_format(axis='x', style='sci', scilimits=(0,0),useLocale=True)\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "ax.tick_params(axis='y', labelsize=fontsize-2)\n",
    "y = .95\n",
    "dy = 0.075\n",
    "for tts in range(len(seq_len)):\n",
    "    ax.annotate('T={}'.format(seq_len[tts]), xy=(.8,y-tts*dy),xycoords='axes fraction',color=clrs_b[tts],fontsize=fontsize-2)\n",
    "tts+=1\n",
    "ax.annotate('SLDS', xy=(.8,y-tts*dy),xycoords='axes fraction',color=clrs[2],fontsize=fontsize-2)\n",
    "tts += 1\n",
    "ax.annotate('rSLDS', xy=(.8,y-tts*dy),xycoords='axes fraction',color=clrs[6],fontsize=fontsize-2)\n",
    "\n",
    "\n",
    "states_z_test = data_dict['states_z_test']\n",
    "ax = axs[2]\n",
    "As = np.stack([v for v in data_dict['As'].values()])\n",
    "timescales_As = 1/np.abs(np.real(np.log(np.linalg.eigvals(As)))[:,:,0].reshape(-1))\n",
    "# timescales_As = 1/np.abs(np.log(np.real(np.linalg.eigvals(As)))[:,:,0].reshape(-1))\n",
    "ts = 0\n",
    "dts = 1/len(seq_len)\n",
    "y_ranges = np.arange(0,1,(dts*dts)).reshape(-1,len(seq_len))[:,(0,-1)]\n",
    "for ts in range(len(seq_len)):\n",
    "    for seed in seeds: \n",
    "        R_bar = result_dict_all['seed_{}'.format(seed)]['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "        R_hat = result_dict_all['seed_{}'.format(seed)]['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "\n",
    "        ##### Plottign Eigenvalues #####\n",
    "        Uhat_all = []\n",
    "        for state in range(len(np.unique(full_state_z[0]))):\n",
    "            # rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "            # model = VAR(rhat2)\n",
    "            # results = model.fit(maxlags=20,ic='aic')\n",
    "            # eig_Ut = np.linalg.eigvals(results.coefs).reshape(-1)\n",
    "            # Uhat_all.append(eig_Ut.reshape(-1))\n",
    "        # for p in range(ssm_params.Nlds):\n",
    "        #     for state in range(ssm_params.n_disc_states):\n",
    "                # rhat2 = R_hat[np.where(states_z_test[p]==state)[0],:]\n",
    "            rhat2 = R_hat[np.where(full_state_z[0]==state)[0],:]\n",
    "            Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "            Uhat_all.append(Uhat_0)\n",
    "\n",
    "        Uhat_all = np.stack(Uhat_all)\n",
    "        # evals_Uhat_all = np.hstack(Uhat_all)\n",
    "        # timescales = 1/np.abs(np.log(np.real(evals_Uhat_all)))\n",
    "        # timescales = np.real(np.log(Uhat_all))\n",
    "        evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "        timescales = 1/np.abs(np.real(np.log(evals_Uhat_all)))\n",
    "        # timescales = 1/np.abs(np.log(np.real(evals_Uhat_all)))\n",
    "        \n",
    "        ax.scatter(x=timescales,y=np.abs(evals_Uhat_all)+ts,\n",
    "                c=clrs_b[ts],alpha=.75,edgecolor='None',s=25)\n",
    "\n",
    "    for n in range(len(timescales_As)):\n",
    "        ax.axvline(x=timescales_As[n],c=sys_clrs[clr_ind[n]])\n",
    "        ax.axhline(y=ts,c=clrs_b[ts],linestyle='--',zorder=-1)\n",
    "    # ax = plot_hist(timescales,-1.75,.1,.1,ax,'TiDHy',clr=clrs_b[ts])\n",
    "    ax.set_xscale('symlog',linthresh=.1)\n",
    "    ax.set_yticks([1/2 + q for q in range(len(seq_len))])\n",
    "    ax.set_yticklabels(seq_len,fontsize=fontsize-2)\n",
    "    ax.set_ylabel('T',fontsize=fontsize,labelpad=-2)\n",
    "    # ax.spines.left.set_visible(False)\n",
    "    ax.set_xlabel('timescales',fontsize=fontsize,labelpad=-3)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "ax.set_xscale('symlog',linthresh=.015)\n",
    "y = .99\n",
    "dy = 0.075\n",
    "ax.annotate('System 1', xy=(.01,y),xycoords='axes fraction',color=sys_clrs[clr_ind[0]],fontsize=fontsize-2)\n",
    "ax.annotate('System 2', xy=(.01,y-dy),xycoords='axes fraction',color=sys_clrs[clr_ind[2]],fontsize=fontsize-2)\n",
    "ax.annotate('System 3', xy=(.01,y-2*dy),xycoords='axes fraction',color=sys_clrs[clr_ind[4]],fontsize=fontsize-2)\n",
    "\n",
    "ax=axs[0]\n",
    "spacing= 5\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['R_hat'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['R_hat'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_ylabel('$\\hat{r}$',fontsize=fontsize,labelpad=-2)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "ax.set_xticks(np.arange(0,dt+(dt//4),(dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,dt+(dt//4),(dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "ax.set_xlim([0,dt])\n",
    "y = .95\n",
    "dy = 0.075\n",
    "for tts in range(len(seq_len)):\n",
    "    ax.annotate('T={}'.format(seq_len[tts]), xy=(1.05,y-tts*dy),xycoords='axes fraction',color=clrs_b[tts],fontsize=fontsize-2)\n",
    "\n",
    "# legend = ax.legend(['T={}'.format(seq_len[p]) for p in range(len(seq_len))],frameon=False,fontsize=fontsize,loc='upper right',\n",
    "#           bbox_to_anchor=(1.25,1),labelcolor=clrs_b,handlelength=0,handleheight=0,ncols=1)\n",
    "\n",
    "\n",
    "ax = axs[1]\n",
    "state_compare = np.concatenate([SLDS_states[:1,:],pred_all[0],full_state_z[:1,:]],axis=0)\n",
    "cmap2,norm = map_discrete_cbar(cmap_b,len(np.unique(full_state_z[0])))\n",
    "acc_slds = accuracy_score(full_state_z[0], SLDS_states[0])\n",
    "TiDHy_acc = ['T={} \\n {:02}%'.format(seq_len[n],int(np.round(scores_all[0,n]*100))) for n in range(len(scores_all[0]))]\n",
    "Ylabels = ['SLDS \\n {:02}%'.format(int(np.round(acc_slds*100)))] + TiDHy_acc + ['True']  \n",
    "im = ax.pcolormesh(state_compare[:,t:t+dt],cmap=cmap2,norm=norm,alpha=.5,rasterized=True)\n",
    "# ax.set_xticks(np.arange(0,dt+200,200))\n",
    "# ax.set_xticklabels(np.arange(0,dt+200,200),fontsize=fontsize)\n",
    "ax.set_xticks(np.arange(0,dt+(dt//4),(dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,dt+(dt//4),(dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(np.arange(.5,len(Ylabels),1))\n",
    "ax.set_yticklabels(Ylabels,fontsize=fontsize-2)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "\n",
    "cbar = fig.colorbar(im,ax=ax,aspect=10, pad=-.2)\n",
    "cbar.set_ticks(np.arange(0,len(np.unique(full_state_z)),1))\n",
    "cbar.set_ticklabels([''.join(lst2[n]) for n in np.arange(len(lst2)-1,-1,-1)],fontsize=fontsize)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")\n",
    "fig.savefig(fig_path/'{}_Fig3.pdf'.format(0),dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bba3fa6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = 1\n",
    "Input_Errors = np.abs(I-result_dict['{}'.format(seq_len[ts])]['I_hat'])\n",
    "np.mean(Input_Errors),np.std(Input_Errors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e38dd9d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(constrained_layout=True, figsize=(8,6))\n",
    "gs0 = gridspec.GridSpec(nrows=4,ncols=2, figure=fig, wspace=.15,hspace=.2)\n",
    "axs = np.array([fig.add_subplot(gs0[:2,0]),fig.add_subplot(gs0[2:,0]),fig.add_subplot(gs0[:2,1]),fig.add_subplot(gs0[2:,1])])\n",
    "t=1500; dt=1000\n",
    "# seq_len=[100,200,500]\n",
    "\n",
    "Input_Errors_SLDS = (inputs_test_SLDS-SLDS_emission)\n",
    "ax = axs[0]\n",
    "Input_Errors_SLDS = np.abs(inputs_test_SLDS-SLDS_emission)\n",
    "Input_Errors_rSLDS = np.abs(inputs_test_SLDS-rSLDS_emission)\n",
    "err_slds  = 100*(1-accuracy_score(full_state_z, SLDS_states))\n",
    "err_rslds = 100*(1-accuracy_score(full_state_z, rSLDS_states))\n",
    "for ts in range(len(seq_len)):\n",
    "    Input_Errors = np.abs(I-result_dict['{}'.format(seq_len[ts])]['I_hat'])\n",
    "    err_TiDHy = 100*(1-accuracy_score(full_state_z, y_pred))\n",
    "    ax.scatter(x=np.mean(Input_Errors),y=err_TiDHy, s=25, c=clrs_b[ts],label='TiDHy')\n",
    "    ax.errorbar(x=np.mean(Input_Errors),y=err_TiDHy, ecolor=clrs_b[ts],xerr=np.std(Input_Errors))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "\n",
    "ax.scatter(x=np.mean(Input_Errors_SLDS),y=err_slds, s=25, c=clrs[2],label='SLDS')\n",
    "ax.errorbar(x=np.mean(Input_Errors_SLDS),y=err_slds, ecolor=clrs[2],xerr=np.std(Input_Errors_SLDS))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "ax.scatter(x=np.mean(Input_Errors_rSLDS),y=err_rslds, s=25,c=clrs[6],label='rSLDS')\n",
    "ax.errorbar(x=np.mean(Input_Errors_rSLDS),y=err_rslds, ecolor=clrs[6],xerr=np.std(Input_Errors_rSLDS))#/np.sqrt(len(Input_Errors_SLDS)))\n",
    "ax.set_yticks([0,25,50,75,100])\n",
    "ax.set_xlabel('reconstruction error',fontsize=fontsize)\n",
    "ax.set_ylabel('dyn. % error',fontsize=fontsize)\n",
    "ax.ticklabel_format(axis='x', style='sci', scilimits=(0,0),useLocale=True)\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "ax.tick_params(axis='y', labelsize=fontsize-2)\n",
    "y = .95\n",
    "dy = 0.075\n",
    "for tts in range(len(seq_len)):\n",
    "    ax.annotate('T={}'.format(seq_len[tts]), xy=(.8,y-tts*dy),xycoords='axes fraction',color=clrs_b[tts],fontsize=fontsize-2)\n",
    "tts+=1\n",
    "ax.annotate('SLDS', xy=(.8,y-tts*dy),xycoords='axes fraction',color=clrs[2],fontsize=fontsize-2)\n",
    "tts += 1\n",
    "ax.annotate('rSLDS', xy=(.8,y-tts*dy),xycoords='axes fraction',color=clrs[6],fontsize=fontsize-2)\n",
    "\n",
    "\n",
    "states_z_test = data_dict['states_z_test']\n",
    "ax = axs[1]\n",
    "As = np.stack([v for v in data_dict['As'].values()])\n",
    "timescales_As = 1/np.abs(np.real(np.log(np.linalg.eigvals(As)))[:,:,0].reshape(-1))\n",
    "ts = 0\n",
    "dts = 1/len(seq_len)\n",
    "y_ranges = np.arange(0,1,(dts*dts)).reshape(-1,len(seq_len))[:,(0,-1)]\n",
    "for ts in range(len(seq_len)):\n",
    "    R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "    R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "\n",
    "    ##### Plottign Eigenvalues #####\n",
    "    Uhat_all = []\n",
    "    for state in range(len(np.unique(full_state_z))):\n",
    "        # rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "        # model = VAR(rhat2)\n",
    "        # results = model.fit(maxlags=20,ic='aic')\n",
    "        # eig_Ut = np.linalg.eigvals(results.coefs).reshape(-1)\n",
    "        # Uhat_all.append(eig_Ut.reshape(-1))\n",
    "    # for p in range(ssm_params.Nlds):\n",
    "    #     for state in range(ssm_params.n_disc_states):\n",
    "            # rhat2 = R_hat[np.where(states_z_test[p]==state)[0],:]\n",
    "        rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "        Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "        Uhat_all.append(Uhat_0)\n",
    "\n",
    "    Uhat_all = np.stack(Uhat_all)\n",
    "    # evals_Uhat_all = np.hstack(Uhat_all)\n",
    "    # timescales = 1/np.abs(np.log(np.real(evals_Uhat_all)))\n",
    "    # timescales = np.real(np.log(Uhat_all))\n",
    "    evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "    timescales = 1/np.abs(np.real(np.log(evals_Uhat_all)))\n",
    "    \n",
    "    ax.scatter(x=timescales,y=np.abs(evals_Uhat_all)+ts,\n",
    "               c=clrs_b[ts],alpha=.75,edgecolor='None',s=25)\n",
    "\n",
    "    for n in range(len(timescales_As)):\n",
    "        ax.axvline(x=timescales_As[n],c=sys_clrs[clr_ind[n]])\n",
    "        ax.axhline(y=ts,c=clrs_b[ts],linestyle='--',zorder=-1)\n",
    "    # ax = plot_hist(timescales,-1.75,.1,.1,ax,'TiDHy',clr=clrs_b[ts])\n",
    "    ax.set_xscale('symlog',linthresh=.1)\n",
    "    ax.set_yticks([1/2 + q for q in range(len(seq_len))])\n",
    "    ax.set_yticklabels(seq_len,fontsize=fontsize-2)\n",
    "    ax.set_ylabel('T',fontsize=fontsize,labelpad=-2)\n",
    "    # ax.spines.left.set_visible(False)\n",
    "    ax.set_xlabel('timescales',fontsize=fontsize,labelpad=-3)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "ax.set_xscale('symlog',linthresh=.015)\n",
    "y = .99\n",
    "dy = 0.075\n",
    "ax.annotate('System 1', xy=(.01,y),xycoords='axes fraction',color=sys_clrs[clr_ind[0]],fontsize=fontsize-2)\n",
    "ax.annotate('System 2', xy=(.01,y-dy),xycoords='axes fraction',color=sys_clrs[clr_ind[2]],fontsize=fontsize-2)\n",
    "ax.annotate('System 3', xy=(.01,y-2*dy),xycoords='axes fraction',color=sys_clrs[clr_ind[4]],fontsize=fontsize-2)\n",
    "\n",
    "ax=axs[2]\n",
    "spacing= 5\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['R_hat'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['R_hat'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_ylabel('$\\hat{r}$',fontsize=fontsize,labelpad=-2)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "ax.set_xticks(np.arange(0,dt+(dt//4),(dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,dt+(dt//4),(dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "ax.set_xlim([0,dt])\n",
    "y = .95\n",
    "dy = 0.075\n",
    "for tts in range(len(seq_len)):\n",
    "    ax.annotate('T={}'.format(seq_len[tts]), xy=(1.05,y-tts*dy),xycoords='axes fraction',color=clrs_b[tts],fontsize=fontsize-2)\n",
    "\n",
    "# legend = ax.legend(['T={}'.format(seq_len[p]) for p in range(len(seq_len))],frameon=False,fontsize=fontsize,loc='upper right',\n",
    "#           bbox_to_anchor=(1.25,1),labelcolor=clrs_b,handlelength=0,handleheight=0,ncols=1)\n",
    "\n",
    "\n",
    "ax = axs[3]\n",
    "TiDHy_acc = ['T={} \\n {:02}%'.format(seq_len[n],int(np.round(acc_TiDHy_all[n]*100))) for n in range(len(acc_TiDHy_all))]\n",
    "Ylabels = ['SLDS \\n {:02}%'.format(int(np.round(acc_ssm*100)))] + TiDHy_acc + ['True']  \n",
    "im = ax.pcolormesh(state_compare[:,t:t+dt],cmap=cmap2,norm=norm,alpha=.5,rasterized=True)\n",
    "# ax.set_xticks(np.arange(0,dt+200,200))\n",
    "# ax.set_xticklabels(np.arange(0,dt+200,200),fontsize=fontsize)\n",
    "ax.set_xticks(np.arange(0,dt+(dt//4),(dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,dt+(dt//4),(dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(np.arange(.5,len(Ylabels),1))\n",
    "ax.set_yticklabels(Ylabels,fontsize=fontsize-2)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "\n",
    "cbar = fig.colorbar(im,ax=ax,aspect=10, pad=-.2)\n",
    "cbar.set_ticks(np.arange(0,len(np.unique(full_state_z)),1))\n",
    "cbar.set_ticklabels([''.join(lst2[n]) for n in np.arange(len(lst2)-1,-1,-1)],fontsize=fontsize)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")\n",
    "fig.savefig(cfg.paths.fig_dir/'{}_Fig3.pdf'.format(nfig),dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60973a9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trade off plot between accuracy of reconstruction and correct identification of unique timescales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9ad0c02",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1,1,figsize=(5,3))\n",
    "ax = axs\n",
    "dts = 1/len(np.unique(full_state_z))\n",
    "y_ranges=np.repeat([[0,1]],3,axis=0)\n",
    "timescales_As = 1/np.abs(np.real(np.log(np.linalg.eigvals(As)))[:,:,0].reshape(-1))\n",
    "evals_As = np.linalg.eigvals(As)[:,:,0].reshape(-1)\n",
    "R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "Uhat_all = []\n",
    "for state in range(len(np.unique(full_state_z))):\n",
    "    rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "    Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "    Uhat_all.append(Uhat_0)\n",
    "    \n",
    "# for p in range(ssm_params.Nlds):\n",
    "#     for state in range(ssm_params.n_disc_states):\n",
    "#         rhat2 = R_hat[np.where(states_z_test[p]==state)[0],:]\n",
    "#         Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "#         Uhat_all.append(Uhat_0)\n",
    "        \n",
    "Uhat_all = np.stack(Uhat_all)\n",
    "evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "timescales = 1/np.abs(np.real(np.log(evals_Uhat_all)))\n",
    "ax.scatter(x=timescales,y=np.abs(evals_Uhat_all),\n",
    "            c='k',s=40,alpha=.5,edgecolor='None')\n",
    "for n in range(len(timescales_As)):\n",
    "    ax.axvline(x=timescales_As[n],c=sys_clrs[clr_ind[n]])\n",
    "    ax.scatter(x=timescales_As[n],y=np.abs(evals_As[n]),\n",
    "            c=sys_clrs[clr_ind[n]],s=40,alpha=1,edgecolor='None')\n",
    "ax.set_xscale('symlog',linthresh=.1)\n",
    "ax.set_yticks([0,.5,1])\n",
    "ax.set_ylim(0,1.1)\n",
    "# ax.set_yticks([np.diff(y_ranges)[0,0]/2 + q*dts for q in range(len(np.unique(full_state_z)))])\n",
    "# ax.set_yticklabels([''.join(lst2[n]) for n in range(len(lst2))],fontsize=fontsize-2)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "ax.set_ylabel('|$\\lambda$|',fontsize=fontsize)\n",
    "y = 1\n",
    "dy = 0.15\n",
    "ax.annotate('system 1', xy=(.01,y),xycoords='axes fraction',color=sys_clrs[clr_ind[0]],fontsize=fontsize-3.5)\n",
    "ax.annotate('system 2', xy=(.01,y-dy),xycoords='axes fraction',color=sys_clrs[clr_ind[2]],fontsize=fontsize-3.5)\n",
    "ax.annotate('system 3', xy=(.01,y-2*dy),xycoords='axes fraction',color=sys_clrs[clr_ind[4]],fontsize=fontsize-3.5)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.set_xlabel('timescales',fontsize=fontsize,labelpad=-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19f50830",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig,axs = plt.subplots(1,1,figsize=(4,4))\n",
    "seq_len=[100,200,500,1000]\n",
    "states_z_test = data_dict['states_z_test']\n",
    "ax = axs\n",
    "As = np.stack([v for v in data_dict['As'].values()])\n",
    "timescales_As = 1/np.abs(np.real(np.log(np.linalg.eigvals(As))))[:,:,0].reshape(-1)\n",
    "ts = 0\n",
    "dts = 1/len(seq_len)\n",
    "y_ranges = np.arange(0,1,(dts*dts)).reshape(-1,len(seq_len))[:,(0,-1)]\n",
    "for ts in range(len(seq_len)):\n",
    "    # R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "    # R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "\n",
    "    # ##### Plottign Eigenvalues #####\n",
    "    # Uhat_all = []\n",
    "    # for p in range(ssm_params.Nlds):\n",
    "    #     for state in range(ssm_params.n_disc_states):\n",
    "    #         # rhat2 = R_hat[np.where(states_z_test[p]==k)[0],:]\n",
    "    #         rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "    #         Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "    #         Uhat_all.append(Uhat_0)\n",
    "    for state in range(len(np.unique(full_state_z))):\n",
    "        Ut_state = U_t[np.where(full_state_z==state)[0],:,:]\n",
    "        Ut_state = Ut_state[np.where(np.sum(Ut_state,axis=(-1,-2))!=0)[0],:,:]\n",
    "        eig_Ut = np.linalg.eigvals(Ut_state).reshape(-1)\n",
    "        timescales = 1/np.abs(np.real(np.log(eig_Ut)))\n",
    "    # Uhat_all = np.stack(Uhat_all)\n",
    "    # evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "    # timescales = np.real(np.log(evals_Uhat_all))\n",
    "        ax.scatter(x=timescales,y=np.abs(eig_Ut)+ts,\n",
    "               c=clrs_b[ts],alpha=.75,edgecolor='None',s=25)\n",
    "        # ax.scatter(x=timescales,y=np.random.uniform(y_ranges[ts,0],y_ranges[ts,1],timescales.shape[0]),\n",
    "        #         c=clrs_b[ts],alpha=.5,edgecolor='None')\n",
    "\n",
    "    for n in range(len(timescales_As)):\n",
    "        ax.axvline(x=timescales_As[n],c=sys_clrs[clr_ind[n]])\n",
    "    # ax = plot_hist(timescales,-1.75,.1,.1,ax,'TiDHy',clr=clrs_b[ts])\n",
    "    # ax.set_yticks([np.diff(y_ranges)[0,0]/2 + q*dts for q in range(len(seq_len))])\n",
    "    # ax.set_yticklabels(seq_len,fontsize=fontsize)\n",
    "    ax.set_ylabel('T',fontsize=fontsize)\n",
    "    # ax.spines.left.set_visible(False)\n",
    "    ax.set_xlabel('log(Re($\\lambda$))',fontsize=fontsize)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "ax.set_xscale('symlog',linthresh=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ecd7eb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1,1,figsize=(8,4))\n",
    "ax = axs\n",
    "TiDHy_acc = ['T={} \\n {:02}%'.format(seq_len[n],int(np.round(acc_TiDHy_all[n]*100))) for n in range(len(acc_TiDHy_all))]\n",
    "Ylabels = ['SLDS \\n {:02}%'.format(int(np.round(acc_ssm*100)))] + TiDHy_acc + ['True']  \n",
    "im = ax.pcolormesh(state_compare[:,t:t+dt],cmap=cmap2,norm=norm,alpha=.5,rasterized=True)\n",
    "ax.set_xticks(np.arange(0,dt+200,200))\n",
    "ax.set_xticklabels(np.arange(0,dt+200,200),fontsize=fontsize)\n",
    "ax.set_yticks(np.arange(.5,len(Ylabels),1))\n",
    "ax.set_yticklabels(Ylabels,fontsize=fontsize)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "\n",
    "cbar = fig.colorbar(im,ax=ax,aspect=10, pad=.01)\n",
    "cbar.set_ticks(np.arange(0,len(np.unique(full_state_z)),1))\n",
    "cbar.set_ticklabels([''.join(lst2[n]) for n in range(len(lst2))],fontsize=fontsize)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec50b2ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_hist(trace,lim0,lim1,hbins,ax,label,clr='k',alpha=.5):\n",
    "    count,edges = np.histogram(trace,bins=np.arange(lim0,lim1,hbins))\n",
    "    edges_mid = np.array([(edges[i]+edges[i+1])/2 for i in range(len(edges)-1)])\n",
    "    ax.bar(edges_mid, count/len(trace),color=clr,width=hbins, alpha=alpha,zorder=1,label=label) \n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28fb4d42",
   "metadata": {},
   "outputs": [],
   "source": [
    "Input_Errors_SLDS = (inputs_test_SLDS-SLDS_emission)\n",
    "\n",
    "fig,axs = plt.subplots(1,1,figsize=(4,4))\n",
    "ax = axs\n",
    "for ts in range(len(seq_len[1:2])):\n",
    "    Input_Errors = (I-result_dict['{}'.format(seq_len[ts])]['I_hat'])\n",
    "    plot_hist(Input_Errors.flatten(),0,.1,1e-3,ax,'TiDHy:T={}'.format(seq_len[ts+1]),clr=clrs_b[ts])\n",
    "# plot_hist(Input_Errors_SLDS.flatten(),0,1,1e-1,ax,'SLDS',clr='k')\n",
    "ax.legend(frameon=False,fontsize=fontsize,loc='upper right',bbox_to_anchor=(1.1,1.1),labelcolor='linecolor',handlelength=0,handleheight=0,ncols=1)\n",
    "ax.set_xlabel('reconstruction error',fontsize=fontsize)\n",
    "ax.set_ylabel('proportion',fontsize=fontsize)\n",
    "plt.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'{}hist.png'.format(nfig),dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d57d7d3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(inputs_test_SLDS[:100,1])\n",
    "plt.plot(SLDS_emission[:100,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92a02fec",
   "metadata": {},
   "outputs": [],
   "source": [
    "Input_Errors_SLDS = (inputs_test_SLDS-SLDS_emission)\n",
    "\n",
    "fig,axs = plt.subplots(1,1,figsize=(4,4))\n",
    "ax = axs\n",
    "total_error = []\n",
    "for ts in range(len(seq_len)):\n",
    "    Input_Errors = (I-result_dict['{}'.format(seq_len[ts])]['I_hat'])\n",
    "    total_error.append(Input_Errors)\n",
    "total_error.append(Input_Errors_SLDS)\n",
    "total_error = np.stack(total_error)\n",
    "\n",
    "ax.boxplot(np.mean(np.abs(total_error),axis=(1)).T)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b84899f",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_comp = 2\n",
    "t=0; dt = 1000\n",
    "cmap2,norm = map_discrete_cbar(cmap,len(np.unique(full_state_z)))\n",
    "fig, axs = plt.subplots(2,2,figsize=(20,12))\n",
    "axs = axs.flatten()\n",
    "fontsize=20\n",
    "ax = axs[0]\n",
    "spacing= 1\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['R2_hat'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['R2_hat'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "X,Y = np.meshgrid(np.arange(0,dt),np.arange(-.5,.75,.25))\n",
    "# im = ax.pcolormesh(X,Y,np.tile(full_state_z[None,t:t+dt],(Y.shape[0],1)),cmap=cmap,norm=norm,alpha=.5,rasterized=True,zorder=-1)\n",
    "ax.set_ylabel('$\\hat{r}^h$',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "ax.legend(['T={}'.format(Ln) for Ln in seq_len],frameon=False,fontsize=fontsize,loc='upper right',bbox_to_anchor=(1.15,1.05),labelcolor=clrs_b,handlelength=0,handleheight=0,ncols=1,columnspacing=.1)\n",
    "\n",
    "ax = axs[1]\n",
    "spacing= 1\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['W'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['W'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "X,Y = np.meshgrid(np.arange(0,dt),np.arange(0,2.25,.25))\n",
    "# im = ax.pcolormesh(X,Y,np.tile(full_state_z[None,t:t+dt],(Y.shape[0],1)),cmap=cmap,norm=norm,alpha=.5,rasterized=True,zorder=-1)\n",
    "ax.set_ylabel('W',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "ax = axs[2]\n",
    "r_x = 'R_bar'\n",
    "ax.set_ylabel(r_x,fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "spacing= 1.5\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])][r_x].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])][r_x][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "\n",
    "ax = axs[3]\n",
    "spacing= 1\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['I_hat'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['I_hat'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "for n in range(result_dict['{}'.format(seq_len[p])]['I_hat'].shape[-1]):\n",
    "    trace = result_dict['{}'.format(seq_len[p])]['I'][t:t+dt,n]\n",
    "    mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "    ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[-1],alpha=.5)\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "ax.set_ylabel('$\\hat{Z}$',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "plt.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'{}_TempWindExpansion.png'.format(nfig),dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4541b48a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for t in range(10):\n",
    "    # As[states_z_test[:,t]]\n",
    "full_state_As = np.stack([As[(0,1,2),lst[n]] for n in range(len(lst))])\n",
    "\n",
    "timescales_As = 1/np.abs(np.real(np.log(np.linalg.eigvals(full_state_As))))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10fdc1ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1,1,figsize=(4,4))\n",
    "ax = axs\n",
    "dts = 1/len(np.unique(full_state_z))\n",
    "y_ranges = np.arange(0,1,(dts*dts)).reshape(-1,len(np.unique(full_state_z)))[:,(0,-1)]\n",
    "ts=0\n",
    "R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "for state in range(len(np.unique(full_state_z))):\n",
    "\n",
    "    ##### Plottign Eigenvalues #####\n",
    "    Uhat_all = []; SLDS_all=[]\n",
    "    rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "    Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "    eig_Ut = np.linalg.eigvals(Uhat_0)\n",
    "    timescales = 1/np.abs(np.real(np.log(eig_Ut)))\n",
    "    \n",
    "    for p in range(timescales_As.shape[1]):\n",
    "        for k in range(timescales_As.shape[2]):\n",
    "            ax.axvline(x=timescales_As[state,p,k],ymin=y_ranges[state,0],ymax=y_ranges[state,1],c=clrs[state])\n",
    "# plot_hist(timescales,-2,.1,.1,ax,'TiDHy',clr=clrs[state])\n",
    "    ax.scatter(x=timescales,y=np.abs(eig_Ut)+state,\n",
    "                c=clrs[state],s=40,alpha=.75,edgecolor='None')\n",
    "# ax.set_xscale('symlog',linthresh=1)\n",
    "ax.set_yticks([q+.5 for q in range(len(np.unique(full_state_z)))])\n",
    "ax.set_yticklabels([''.join(lst2[n]) for n in range(len(lst2))],fontsize=fontsize)\n",
    "# ax.set_xticks([0,-10e0,-10e-1])\n",
    "ax.tick_params(axis='x', labelsize=fontsize)\n",
    "ax.set_xlabel('log(Re($\\lambda$))',fontsize=fontsize)\n",
    "# ax.set_ylabel('T',fontsize=fontsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ea08801",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(3,2,figsize=(15,10))\n",
    "minmax = 10\n",
    "for n in range(As.shape[0]):\n",
    "    for m in range(As.shape[1]):\n",
    "        ax = axs[n,m]\n",
    "        q = plot_dynamics_2d(As[n,m], \n",
    "                            bias_vector=bs[n,m],#np.zeros(2),\n",
    "                            mins=[-minmax,-minmax],#plot_x.min(axis=0),\n",
    "                            maxs=[minmax,minmax],#plot_x.max(axis=0),\n",
    "                            npts=7,\n",
    "                            axis=ax)\n",
    "        ax.axis('off')\n",
    "        ax.axis('equal')\n",
    "# fig.savefig(cfg.paths.fig_dir / 'dynamics.pdf', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6cf980a",
   "metadata": {},
   "outputs": [],
   "source": [
    "figsize= (5,4)\n",
    "t=0; dt = 1000\n",
    "ts = -1\n",
    "##### Calculated correlation ######\n",
    "# R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "R_hat = SLDS_latents\n",
    "states_x_test = result_dict['{}'.format(seq_len[ts])]['states_x_test']/np.max(np.abs(result_dict['{}'.format(seq_len[ts])]['states_x_test']),axis=0)\n",
    "# states_x_test = result_dict['{}'.format(seq_len[ts])]['states_x_train']/np.max(np.abs(result_dict['{}'.format(seq_len[ts])]['states_x_train']),axis=0)\n",
    "# R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "ccs = np.zeros((R_hat.shape[-1],states_x_test.shape[-1]))\n",
    "for n in range(R_hat.shape[-1]):\n",
    "    for m in range(states_x_test.shape[-1]):\n",
    "        ccs[n,m] = np.corrcoef(R_hat[:,n],states_x_test[:,m])[0,1]\n",
    "Rhat_plot = np.zeros_like(states_x_test)\n",
    "# Rbar_plot = np.zeros_like(states_x_test)\n",
    "x_plot = np.zeros_like(R_hat)\n",
    "norm = True\n",
    "ind = np.zeros((states_x_test.shape[-1],),dtype=int)\n",
    "for n in range(states_x_test.shape[-1]):\n",
    "    ind[n] = np.nanargmax(np.abs(ccs[:,n]))\n",
    "    flip_Rhat = -1 if ccs[ind[n],n,] < 0 else 1\n",
    "    Rhat_plot[:,n] = flip_Rhat*R_hat[:,ind[n]]\n",
    "    # Rbar_plot[:,n] = flip_Rhat*R_bar[:,ind[n]]\n",
    "    if norm:\n",
    "        Rhat_plot[:,n] = Rhat_plot[:,n]/np.max(np.abs(Rhat_plot[:,n]))\n",
    "        # Rbar_plot[:,n] = Rbar_plot[:,n]/np.max(np.abs(Rbar_plot[:,n]))\n",
    "# R_acor = np.stack([autocorr(R_hat[:,n],norm=norm) for n in range(R_hat.shape[-1])],axis=1)\n",
    "# x_acor = np.stack([autocorr(states_x_test[:,n],norm=norm) for n in range(states_x_test.shape[-1])],axis=1)\n",
    "\n",
    "print(ind,np.max(np.abs(np.round(ccs,decimals=2)),axis=0))\n",
    "\n",
    "\n",
    "##### Plotting latent states #####\n",
    "spacing= .5\n",
    "max_ccs = np.max(np.abs(np.round(ccs,decimals=2)),axis=0)\n",
    "fig,axs = plt.subplots(1,1,figsize=(5,5),sharey=True,gridspec_kw={'wspace':.15})\n",
    "ax = axs\n",
    "colormap = plt.get_cmap(cmap, len(np.unique(full_state_z)))\n",
    "hlines_x,hlines_Rhat = [],[]\n",
    "for n in range(states_x_test.shape[-1]):\n",
    "    mean_centered_x = states_x_test[t:t+dt,n] - np.mean(states_x_test[t:t+dt,n],axis=0)\n",
    "    ax.plot(mean_centered_x + n/spacing,color='k', lw=1,zorder=1)\n",
    "    hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "    mean_centered_Rhat = Rhat_plot[t:t+dt,n] - np.mean(Rhat_plot[t:t+dt,n],axis=0)\n",
    "    ax.plot(mean_centered_Rhat + n/spacing,ls='--',color='r', lw=1,zorder=2,label='$\\hat{{R}}_{{{}}}$={:.02}'.format(ind[n],max_ccs[n]))\n",
    "    hlines_Rhat.append(np.mean(mean_centered_Rhat + n/spacing,axis=0))\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1))\n",
    "ax.set_xlabel('Timesteps',fontsize=fontsize)\n",
    "ax.set_ylabel('$\\hat{{r}}_t$',fontsize=fontsize)\n",
    "ax.set_title('Learned Latent States',fontsize=fontsize)\n",
    "ax.set_xlabel('Time')\n",
    "for n in range(len(hlines_x)):\n",
    "    ax.text(x=dt+15,y=hlines_x[n],s='$r_{{{:d}}}={:.02}$'.format(ind[n],max_ccs[n]),fontsize=10)\n",
    "# ax.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "# fig.savefig(cfg.paths.fig_dir/'{}_Rhat_vs_x.png'.format(nfig),dpi=300)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33fd0f76",
   "metadata": {},
   "source": [
    "# Load Anymal Terrain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9ffe840",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = 'AnymalTerrain'\n",
    "base_dir = Path('/data/users/eabe/hypernets/{}/TiDHy_{}/'.format(dataset,dataset))\n",
    "configs = sorted(list(base_dir.rglob('*config.yaml'))[::2])\n",
    "\n",
    "for n,conf in enumerate(configs):\n",
    "    print(n,conf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c3dfeed",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 1\n",
    "default_model_config = '/home/eabe/Research/MyRepos/HyperNets/conf/dataset/model/default_model.yaml'\n",
    "params = OmegaConf.load(default_model_config)\n",
    "cfg_path =configs[n]# Path('/data/users/eabe/hypernets/SLDS/DPC_SLDS/TestingNoTempLearning/mix_dim=15/config.yaml')\n",
    "cfg = OmegaConf.load(cfg_path)\n",
    "for k in cfg.paths.keys():\n",
    "    cfg.paths[k] = Path(cfg.paths[k])\n",
    "    cfg.paths[k].mkdir(parents=True, exist_ok=True)\n",
    "params_curr = cfg.dataset.model\n",
    "cfg.dataset.model = OmegaConf.merge(params, params_curr)\n",
    "cfg.dataset.train.normalize_obs = False\n",
    "cfg.model.batch_converge=False\n",
    "cfg.model.Orth_alpha_spat = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "238228b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dict, cfg = load_dataset(cfg)\n",
    "# ##### Convert to float tensors #####\n",
    "train_inputs = torch.tensor(data_dict['inputs_train']).float()\n",
    "test_inputs = torch.tensor(data_dict['inputs_test']).float()\n",
    "\n",
    "input_dim = train_inputs.shape[-1]\n",
    "\n",
    "train_inputs = train_inputs.reshape(-1, cfg.train.sequence_length, input_dim)\n",
    "test_inputs = test_inputs.reshape(-1, cfg.train.sequence_length, input_dim)\n",
    "cfg.model.input_dim = input_dim\n",
    "\n",
    "if cfg.train.batch_size_input:\n",
    "    batch_size_train = train_inputs.shape[0]\n",
    "    batch_size_test = test_inputs.shape[0]\n",
    "else:\n",
    "    batch_size_train = cfg.train.batch_size\n",
    "    # batch_size_test = cfg.train.batch_size\n",
    "    batch_size_test = test_inputs.shape[0]\n",
    "\n",
    "train_dataset = torch.utils.data.TensorDataset(train_inputs)\n",
    "test_dataset = torch.utils.data.TensorDataset(test_inputs)\n",
    "dataloader_train = torch.utils.data.DataLoader(train_dataset,batch_size=batch_size_train,pin_memory=True,shuffle=True,drop_last=True)\n",
    "dataloader_test = torch.utils.data.DataLoader(test_dataset,batch_size=batch_size_test,pin_memory=True,drop_last=True)\n",
    "device = torch.device(\"cuda:{}\".format(cfg.train['gpu']) if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b3f4043",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "##### Load weights and params #####\n",
    "rerecord = False\n",
    "epoch = 1000\n",
    "model = TiDHy.TiDHy(cfg.model, device, show_progress=cfg.train.show_progress).to(device)\n",
    "# set_seed(42)\n",
    "load_path = cfg.paths.ckpt_dir/'best.pth.tar'\n",
    "load_path = sorted(list(cfg.paths.ckpt_dir.rglob('last_{}.pth.tar'.format(epoch))))[0]\n",
    "data_load = torch.load(load_path,map_location=device)\n",
    "model.load_state_dict(data_load['state_dict'])\n",
    "model.to(device)\n",
    "print('Loaded from {} epoch'.format(data_load['epoch']))\n",
    "epoch = data_load['epoch']\n",
    "\n",
    "\n",
    "# result_dict = load_results(model, dataloader_test, data_dict, device, cfg, epoch, rerecord=rerecord)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78fc6811",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "fontsize=13\n",
    "\n",
    "clrs = np.array(['#1A237E','#7E57C2','#757575','#BDBDBD','#4CAF50','#FF9800','#795548','#FF4081','#00BCD4','#FF1744','#FFFFFF','#000000'])\n",
    "sys_clrs = ['#E3A19F','#E3BE53','#708090','#90CCA9','#B7522E','#B0E0E6','#A89AC2','#556B2F','#FF6F61','#87CEEB','#FFDAB9','#40E0D0']\n",
    "cmap_sys = ListedColormap(sys_clrs)\n",
    "clr_ind =[2,2,8,8,9,9]\n",
    "# clr2 = [sys_clrs[clr_ind[n]] for n in range(len(clr_ind))]\n",
    "clr_ind3 = [2,8,9]\n",
    "clr2b = [sys_clrs[clr_ind3[n]] for n in range(len(clr_ind3))]\n",
    "\n",
    "clrs_b = clrs[[0,1,2,9,4,6,7,8,11]]\n",
    "cmap = ListedColormap(clrs)\n",
    "# cmap_small = ListedColormap(clrs[:len(np.unique(full_state_z))])\n",
    "cmap_b = ListedColormap(clrs_b)\n",
    "cmap\n",
    "# cmap_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49b51ca8",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_len = [100,200,500,1000]\n",
    "\n",
    "cfg, result_dict = run_seq_len_model(seq_len, model, data_dict, device, epoch, cfg, rerun=False)\n",
    "\n",
    "data_dict, cfg = load_dataset(cfg)\n",
    "seq_len = sorted([int(el) for el in list(result_dict.keys())])\n",
    "seq_len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2943ad50",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "save_figs = False\n",
    "ts=-2\n",
    "W = result_dict['{}'.format(seq_len[ts])]['W'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['W'].shape[-1])\n",
    "# b = result_dict['b'].reshape(-1,result_dict['b'].shape[-1])\n",
    "I = result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1])\n",
    "Ihat = result_dict['{}'.format(seq_len[ts])]['I_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1])\n",
    "Ibar = result_dict['{}'.format(seq_len[ts])]['I_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I_bar'].shape[-1])\n",
    "R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "R2_hat = result_dict['{}'.format(seq_len[ts])]['R2_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R2_hat'].shape[-1])\n",
    "# Ut = result_dict['Ut'].reshape(-1,result_dict['Ut'].shape[-2],result_dict['Ut'].shape[-1])\n",
    "# ##### Plot dynamic matrices #####\n",
    "if cfg.model.low_rank_temp:\n",
    "    Uk = torch.bmm(model.temporal.unsqueeze(-1),model.temporal.unsqueeze(1)).data.cpu().detach()\n",
    "else:\n",
    "    Uk = model.temporal.data.cpu().detach().reshape(model.mix_dim,model.r_dim,model.r_dim)\n",
    "    U_t = torch.matmul(torch.Tensor(W[:,None,:]), model.temporal.unsqueeze(0).cpu().detach()).reshape(-1, model.r_dim, model.r_dim).numpy()\n",
    "\n",
    "nfig = 0\n",
    "t = 0; dt = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50825e69",
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "t=0; dt=1000\n",
    "spacing= .1\n",
    "ts=-2\n",
    "I = result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1])\n",
    "I_shuff  = deepcopy(result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1]))\n",
    "Ihat = result_dict['{}'.format(seq_len[ts])]['I_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1])\n",
    "# fig,axs = plt.subplots(1,2,figsize=(5,3),sharey=True,gridspec_kw={'wspace':.15,'width_ratios':[2,1]})\n",
    "fig,axs = plt.subplots(1,2,figsize=(8,5))\n",
    "ax = axs[0]\n",
    "# cmap,norm = map_discrete_cbar(cmap,len(np.unique(full_state_z)))\n",
    "hlines_I,hlines_Ihat = [],[]\n",
    "for n in range(I.shape[-1]):\n",
    "    mean_centered_I = I[t:t+dt,n] - np.mean(I[t:t+dt,n],axis=0)\n",
    "    ax.plot(mean_centered_I + n/spacing,color='k', lw=1,zorder=1,label='Data')\n",
    "    hlines_I.append(np.mean(mean_centered_I + n/spacing,axis=0))\n",
    "    mean_centered_Ihat = Ihat[t:t+dt,n] - np.mean(Ihat[t:t+dt,n],axis=0)\n",
    "    ax.plot(mean_centered_Ihat + n/spacing,ls='-',color='#4e7eb3ff', lw=1,zorder=2,label='Pred')\n",
    "    hlines_Ihat.append(np.mean(mean_centered_Ihat + n/spacing,axis=0))\n",
    "# X,Y = np.meshgrid(np.arange(0,dt),np.arange(-1,2*I.shape[-1]))\n",
    "# im = ax.pcolormesh(X,Y,np.tile(full_state_z[None,t:t+dt],(2*I.shape[-1]+1,1)),cmap=cmap,norm=norm,alpha=.5,rasterized=True,zorder=-1)\n",
    "# # im = ax.pcolormesh(X,Y,np.tile(full_state_z[None,t:t+dt],(2*I.shape[-1],1)),cmap=cmap,norm=norm,alpha=.5)\n",
    "# cbar = fig.colorbar(im,ax=axs,aspect=30)\n",
    "# cbar.set_ticks(np.arange(.5,len(np.unique(full_state_z)),1))\n",
    "# cbar.set_ticklabels([''.join(lst2[n]) for n in range(len(lst2))],fontsize=fontsize)\n",
    "# cbar.outline.set_linewidth(1)\n",
    "# cbar.minorticks_off()\n",
    "# cbar.ax.tick_params(width=1,which=\"major\")\n",
    "\n",
    "ax.set_yticks(hlines_I)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_I)+1),fontsize=fontsize)\n",
    "# ax.set_xticklabels(np.arange(0,1200,200),fontsize=fontsize)\n",
    "ax.set_xlabel('Timesteps',fontsize=fontsize)\n",
    "ax.set_ylabel('Observation #',fontsize=fontsize)\n",
    "ax.legend(['data','pred'],frameon=False,fontsize=fontsize,loc='upper right',bbox_to_anchor=(1.025,1.05),labelcolor='linecolor',handlelength=0,handleheight=0,ncols=2,columnspacing=.1)\n",
    "\n",
    "# ax.set_title('Learned Observations',fontsize=fontsize)\n",
    "lim0 = 0\n",
    "lim1 = 20\n",
    "hbins = 1\n",
    "Input_Errors = np.mean((I-Ihat)**2,axis=0)\n",
    "# Input_Errors_SLDS = np.mean((inputs_test_SLDS-q_lem_y)**2,axis=0)\n",
    "I_shuff = shuffle_along_axis(I_shuff,axis=1)\n",
    "Input_Errors_shuff = np.mean((I_shuff-Ihat)**2,axis=0)\n",
    "ax = axs[1]\n",
    "count,edges = np.histogram(Input_Errors,bins=np.arange(lim0,lim1,hbins))\n",
    "edges_mid = np.array([(edges[i]+edges[i+1])/2 for i in range(len(edges)-1)])\n",
    "ax.bar(edges_mid, count/len(Input_Errors),color='#757575ff',width=hbins, alpha=1,zorder=1,label='data')\n",
    "count,edges = np.histogram(Input_Errors_shuff,bins=np.arange(lim0,lim1,hbins))\n",
    "edges_mid = np.array([(edges[i]+edges[i+1])/2 for i in range(len(edges)-1)])\n",
    "ax.bar(edges_mid, count/len(Input_Errors),color='r',width=hbins, alpha=1,zorder=1,label='shuffle') \n",
    "# count,edges = np.histogram(Input_Errors_SLDS,bins=np.arange(lim0,lim1,hbins))\n",
    "# edges_mid = np.array([(edges[i]+edges[i+1])/2 for i in range(len(edges)-1)])\n",
    "# ax.bar(edges_mid, count/len(Input_Errors_SLDS),color='g',width=hbins, alpha=.5,zorder=1,label='SLDS') \n",
    "ax.set_ylabel('Proportion',fontsize=fontsize)\n",
    "ax.set_xlabel('MSE',fontsize=fontsize)\n",
    "ax.legend(frameon=False,fontsize=fontsize)\n",
    "# ax = axs[1]\n",
    "# fig,axs = plt.subplots(1,1,figsize=(4,4))\n",
    "# Input_Errors = np.mean((I-Ihat)**2,axis=0)\n",
    "# I_shuff = shuffle_along_axis(I_shuff,axis=1)\n",
    "# Input_Errors_shuff = np.mean((I_shuff-Ihat)**2,axis=0)\n",
    "# xs = np.arange(I.shape[-1])\n",
    "# heights = Input_Errors\n",
    "# ax.barh(y=hlines_I,width=heights,color='k',)\n",
    "# ax.errorbar(heights,hlines_I,xerr=np.std((I-Ihat),axis=0)/np.sqrt((I-Ihat).shape[0]),ls='none',color='tab:gray',capsize=3)\n",
    "# ax.axvline(x=np.mean(Input_Errors_shuff),c='k',ls='--',lw=1,label='shuffle error')\n",
    "# # ax.set_xticks(np.arange(0,.004,.001))\n",
    "# ax.set_xlabel('MSE',fontsize=fontsize)\n",
    "# ax.set_title('Average Error',fontsize=fontsize)\n",
    "# ax.set_xticklabels(np.arange(heights.shape[-1])+1)\n",
    "# ax.legend(bbox_to_anchor=(.3, .95), loc='lower left', borderaxespad=0.,frameon=False,fontsize=fontsize)\n",
    "\n",
    "\n",
    "fig.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'{}_observations_pred.png'.format(nfig),dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55efab31",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_comp = 2\n",
    "t=0; dt = 1000\n",
    "# cmap2,norm = map_discrete_cbar(cmap,len(np.unique(full_state_z)))\n",
    "fig, axs = plt.subplots(2,2,figsize=(20,12))\n",
    "axs = axs.flatten()\n",
    "fontsize=13\n",
    "ax = axs[0]\n",
    "spacing= 1.5\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['R2_hat'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['R2_hat'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "X,Y = np.meshgrid(np.arange(0,dt),np.arange(-.5,.75,.25))\n",
    "# im = ax.pcolormesh(X,Y,np.tile(full_state_z[None,t:t+dt],(Y.shape[0],1)),cmap=cmap,norm=norm,alpha=.5,rasterized=True,zorder=-1)\n",
    "ax.set_ylabel('$\\hat{r}^h$',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "ax.legend(['T={}'.format(Ln) for Ln in seq_len],frameon=False,fontsize=fontsize,loc='upper right',bbox_to_anchor=(1.15,1.05),labelcolor=clrs_b,handlelength=0,handleheight=0,ncols=1,columnspacing=.1)\n",
    "\n",
    "ax = axs[1]\n",
    "spacing= 1.5\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['W'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['W'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "X,Y = np.meshgrid(np.arange(0,dt),np.arange(0,2.25,.25))\n",
    "# im = ax.pcolormesh(X,Y,np.tile(full_state_z[None,t:t+dt],(Y.shape[0],1)),cmap=cmap,norm=norm,alpha=.5,rasterized=True,zorder=-1)\n",
    "ax.set_ylabel('W',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "ax = axs[2]\n",
    "ax.set_ylabel('$\\hat{r}$',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "spacing= 1.5\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['R_bar'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['R_bar'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "\n",
    "ax = axs[3]\n",
    "spacing= 1\n",
    "for p in range(len(seq_len)):\n",
    "    hlines_x = []\n",
    "    for n in range(result_dict['{}'.format(seq_len[p])]['I_hat'].shape[-1]):\n",
    "        trace = result_dict['{}'.format(seq_len[p])]['I_hat'][t:t+dt,n]\n",
    "        mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "        ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[p],alpha=.5)\n",
    "        hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "for n in range(result_dict['{}'.format(seq_len[p])]['I_hat'].shape[-1]):\n",
    "    trace = result_dict['{}'.format(seq_len[p])]['I'][t:t+dt,n]\n",
    "    mean_centered_x = trace - np.mean(trace,axis=0)\n",
    "    ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[-1],alpha=.5)\n",
    "ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "ax.set_ylabel('$\\hat{Z}$',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "plt.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'{}_TempWindExpansion.png'.format(nfig),dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b1073bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "sys_clrs = ['#E3A19F','#E3BE53','#708090','#90CCA9','#B7522E','#B0E0E6','#A89AC2','#556B2F','#FF6F61','#87CEEB','#FFDAB9','#40E0D0']\n",
    "cmap_sys = ListedColormap(sys_clrs)\n",
    "clr_ind = [2,8,9]\n",
    "clr2 = [sys_clrs[clr_ind[n]] for n in range(len(clr_ind))]\n",
    "terrain_names = ['Flat','Slope','Inv. Slope','Stairs','Inv. Stairs']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86b2d9fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "terrain_type_train = data_dict['terrain_train'].reshape(-1)\n",
    "terrain_type_test = data_dict['terrain_test']\n",
    "terrain_difficulty_train = data_dict['terrain_difficulty_train'].reshape(-1)\n",
    "terrain_difficulty_test = data_dict['terrain_difficulty_test'].reshape(-1)\n",
    "terrain_slope_train = data_dict['terrain_slope_train'].reshape(-1)\n",
    "terrain_slope_test = data_dict['terrain_slope_test'].reshape(-1)\n",
    "command_vel_train = data_dict['command_vel_train'].reshape(-1)\n",
    "command_vel_test = data_dict['command_vel_test'].reshape(-1)\n",
    "\n",
    "robot_type_test = data_dict['robot_type_test']\n",
    "terrain_robot_test = np.stack([terrain_type_test[robot_type_test==0].reshape(-1),terrain_type_test[robot_type_test==1].reshape(-1)])\n",
    "terrain_type_test = data_dict['terrain_test'].reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59828be3",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig,axs = plt.subplots(1,1,figsize=(4,4))\n",
    "seq_len=[100,200,500,1000]\n",
    "ax = axs\n",
    "dts = 1/len(seq_len)\n",
    "# timescales_M = 1/np.abs(np.real(np.log(np.linalg.eigvals(M))))[1:]\n",
    "y_ranges = np.arange(0,1,(dts*dts)).reshape(-1,len(seq_len))[:,(0,-1)]\n",
    "for ts in range(len(seq_len)):\n",
    "    # R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "    R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "    R2_hat = result_dict['{}'.format(seq_len[ts])]['R2_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R2_hat'].shape[-1])\n",
    "    I = result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1])\n",
    "\n",
    "    # ##### Plottign Eigenvalues #####\n",
    "    Uhat_all = []\n",
    "    for p in range(terrain_robot_test.shape[0]):\n",
    "        for state in range(len(np.unique(terrain_type_test))):\n",
    "            rhat2 = R_hat[np.where(terrain_robot_test[p]==state)[0],:]\n",
    "            Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "            Uhat_all.append(Uhat_0)\n",
    "            # eig_Ut = np.linalg.eigvals(Uhat_0).reshape(-1)\n",
    "            # timescales = np.real(np.log(eig_Ut))\n",
    "    Uhat_all = np.stack(Uhat_all)\n",
    "    evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "    timescales = np.real(np.log(evals_Uhat_all))\n",
    "\n",
    "    ax.scatter(x=1/np.abs(timescales),y=np.random.uniform(y_ranges[ts,0],y_ranges[ts,1],timescales.shape[0]),\n",
    "            c=clrs_b[ts],alpha=.5,edgecolor='None')\n",
    "\n",
    "# for n in range(len(timescales_M)):\n",
    "#     ax.axvline(x=timescales_M[n],c=sys_clrs[n])\n",
    "ax.set_xscale('symlog',linthresh=10)\n",
    "ax.set_yticks([np.diff(y_ranges)[0,0]/2 + q*dts for q in range(len(seq_len))])\n",
    "ax.set_yticklabels(seq_len,fontsize=fontsize)\n",
    "ax.set_ylabel('T',fontsize=fontsize)\n",
    "# ax.spines.left.set_visible(False)\n",
    "ax.set_xlabel('timescales',fontsize=fontsize)\n",
    "ax.set_xticks([0,10e0,10e1])\n",
    "ax.tick_params(axis='x', labelsize=fontsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d3bb6b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import RidgeClassifier,LogisticRegression, RidgeClassifierCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "ts=-2\n",
    "# nani = terrain.shape[0]\n",
    "# reg_variables = [np.concatenate([result_dict['R2_hat'],result_dict['W'],result_dict['R_bar']],axis=-1),result_dict['R2_hat'],result_dict['W'],result_dict['R_hat'],result_dict['I']]\n",
    "reg_variables = [result_dict['{}'.format(seq_len[ts])]['R2_hat'],result_dict['{}'.format(seq_len[ts])]['I']]\n",
    "labels = ['R2_hat','I']\n",
    "# labels = ['all','R2_hat','W','R_hat','I']\n",
    "robot_type_test = data_dict['robot_type_test']\n",
    "robot_type_test=np.tile(robot_type_test,(9000,1)).transpose(1,0)\n",
    "command_vel_test = np.tile(robot_type_test,(9000,1)).transpose(1,0)\n",
    "# reg_variables = W\n",
    "max_acc = 0\n",
    "tr_batch_size = 40\n",
    "batch_size = 10\n",
    "for k,reg_vars in enumerate(reg_variables):\n",
    "    # X_train = reg_vars[:tr_batch_size].reshape(-1,reg_vars.shape[-1])\n",
    "    # X_test = reg_vars[-batch_size:].reshape(-1,reg_vars.shape[-1])\n",
    "    # y_train = terrain[:tr_batch_size].reshape(-1)\n",
    "    # y_test = terrain[-batch_size:].reshape(-1)\n",
    "    # y_train = robot_type_test[:tr_batch_size].reshape(-1)\n",
    "    # y_test = robot_type_test[-batch_size:].reshape(-1)\n",
    "    X_train, X_test, y_train, y_test = train_test_split(reg_vars.reshape(-1,reg_vars.shape[-1]), terrain_type_test.reshape(-1), test_size=0.25, random_state=42)\n",
    "    # X_train, X_test, y_train, y_test = train_test_split(reg_vars.reshape(-1,reg_vars.shape[-1]), robot_type_test.reshape(-1), test_size=0.25, random_state=42)\n",
    "    neigh = KNeighborsClassifier(n_neighbors=3,n_jobs=-1)\n",
    "    # neigh = RidgeClassifierCV()\n",
    "    neigh.fit(X_train, y_train)\n",
    "    # y_pred = neigh.predict(X_test)\n",
    "    scores = neigh.score(X_test, y_test)\n",
    "    print(labels[k],scores)\n",
    "    if (scores > max_acc) & (labels[k] != 'I'):\n",
    "        y_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "        max_acc = scores\n",
    "        best_reg_vars = reg_vars\n",
    "        best_label = labels[k]\n",
    "        best_pred_terrain = y_pred\n",
    "    else:\n",
    "        I_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "        \n",
    "state_compare = np.stack([I_pred,best_pred_terrain,terrain_type_test])\n",
    "# plt.imshow(confusion_matrix(full_state_z, y_pred),cmap='viridis')\n",
    "# plt.colorbar()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ded530d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "robot_type_test.reshape(-1).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "518a7bba",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import RidgeClassifier,LogisticRegression, RidgeClassifierCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# nani = terrain.shape[0]\n",
    "# reg_variables = [np.concatenate([R2_hat,W,R_bar],axis=-1),R2_hat,W,R_hat,I]\n",
    "# labels = ['all','R2_hat','W','R_hat','I']\n",
    "pca = PCA()\n",
    "X_pca = pca.fit_transform(I.reshape(-1,I.shape[-1]))\n",
    "reg_variables = [R2_hat,I] #,X_pca]\n",
    "labels = ['R2_hat','I'] #,'X_pca']\n",
    "label_type = ['terrain_difficulty_test','terrain_slope_test','command_vel_test']#,'robot_type_test']\n",
    "\n",
    "robot_type_test = data_dict['robot_type_test']\n",
    "robot_type_test=np.tile(robot_type_test,(9000,1)).transpose(1,0).reshape(-1)\n",
    "command_vel_test = np.tile(data_dict['command_vel_test'],(9000,1)).transpose(1,0)\n",
    "slope_cat = np.unique(terrain_slope_test,return_inverse=True)[1]\n",
    "difficulty_cat =  np.unique(terrain_difficulty_test,return_inverse=True)[1]\n",
    "vel_cat = np.unique(command_vel_test,return_inverse=True)[1]\n",
    "# reg_variables = W\n",
    "max_acc = 0\n",
    "tr_batch_size = 40\n",
    "batch_size = 10\n",
    "class_results = {}\n",
    "state_compare_best = {}\n",
    "for m, test_labels in enumerate([difficulty_cat,slope_cat,vel_cat]): #,robot_type_test\n",
    "\n",
    "    for k,reg_vars in enumerate(reg_variables):\n",
    "\n",
    "        X_train, X_test, y_train, y_test = train_test_split(reg_vars.reshape(-1,reg_vars.shape[-1]), test_labels.reshape(-1), test_size=0.25, random_state=42)\n",
    "\n",
    "        neigh = KNeighborsClassifier(n_neighbors=3,n_jobs=-1)\n",
    "        neigh.fit(X_train, y_train)\n",
    "        scores = neigh.score(X_test, y_test)\n",
    "        print(label_type[m],labels[k],scores)\n",
    "        if (labels[k] != 'I'):\n",
    "            y_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "            class_results['{}_{}_pred'.format(label_type[m],labels[k])] = y_pred\n",
    "            class_results['{}_{}_score'.format(label_type[m],labels[k])] = scores\n",
    "            max_acc = scores\n",
    "            best_reg_vars = reg_vars\n",
    "            best_label = labels[k]\n",
    "            best_pred = y_pred\n",
    "        else:\n",
    "            I_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "            class_results['{}_{}_pred'.format(label_type[m],labels[k])] = I_pred\n",
    "            class_results['{}_{}_score'.format(label_type[m],labels[k])] = scores\n",
    "    state_compare_best['{}'.format(label_type[m])] = np.stack([I_pred,best_pred,test_labels],axis=0)\n",
    "\n",
    "# plt.imshow(confusion_matrix(full_state_z, y_pred),cmap='viridis')\n",
    "# plt.colorbar()\n",
    "from sklearn import metrics\n",
    "f1_TiDHy = [metrics.f1_score(state_compare_best[key][-1],state_compare_best[key][1],average='weighted') for key in state_compare_best.keys()]\n",
    "f1_Inputs = [metrics.f1_score(state_compare_best[key][-1],state_compare_best[key][0],average='weighted') for key in state_compare_best.keys()]\n",
    "clrs2 =['#0F4C5C','#F4D03F','#FF6B6B','#2E8B57','#87CEEB','#778899','#40E0D0','#FFDB58','#4169E1','#C2B280','#FFDAB9','#000080','#556B2F','#008080','#FFFDD0','#B7410E','#6A5ACD','#FFBF00','#FFD1DC','#800080','#98FF98','#FA8072','#E6E6FA','#36454F']\n",
    "cmap2 = ListedColormap(clrs2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58bafde4",
   "metadata": {},
   "outputs": [],
   "source": [
    "state_compare_data = {'state_compare_best':state_compare_best,'state_compare':state_compare,'class_results':class_results}\n",
    "ioh5.save(cfg.paths.log_dir/'state_compare.h5',state_compare_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45e59514",
   "metadata": {},
   "outputs": [],
   "source": [
    "state_compare_data = ioh5.load(cfg.paths.log_dir/'state_compare.h5')\n",
    "state_compare = state_compare_data['state_compare']\n",
    "state_compare_best = state_compare_data['state_compare_best']\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "f1_TiDHy = [metrics.f1_score(state_compare_best[key][-1],state_compare_best[key][1],average='weighted') for key in state_compare_best.keys()]\n",
    "f1_Inputs = [metrics.f1_score(state_compare_best[key][-1],state_compare_best[key][0],average='weighted') for key in state_compare_best.keys()]\n",
    "clrs2 =['#0F4C5C','#F4D03F','#FF6B6B','#2E8B57','#87CEEB','#778899','#40E0D0','#FFDB58','#4169E1','#C2B280','#FFDAB9','#000080','#556B2F','#008080','#FFFDD0','#B7410E','#6A5ACD','#FFBF00','#FFD1DC','#800080','#98FF98','#FA8072','#E6E6FA','#36454F']\n",
    "cmap2 = ListedColormap(clrs2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9336d9ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "t=2500; dt=1000\n",
    "fontsize=13\n",
    "fig = plt.figure(constrained_layout=True, figsize=(7.75,5.5))\n",
    "gs0 = gridspec.GridSpec(nrows=6,ncols=3, figure=fig, wspace=.1,hspace=.1)\n",
    "\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(nrows=1,ncols=5, subplot_spec=gs0[:3,:],wspace=.1,hspace=.1)\n",
    "gs01 = gridspec.GridSpecFromSubplotSpec(nrows=1,ncols=5,subplot_spec=gs0[4:,:],wspace=.1,hspace=.2)\n",
    "axs = np.array([fig.add_subplot(gs00[:,:2]),\n",
    "                fig.add_subplot(gs00[:,2:4]),\n",
    "                fig.add_subplot(gs00[:,4:]),\n",
    "                fig.add_subplot(gs01[:,:2]),\n",
    "                fig.add_subplot(gs01[:,2:])])\n",
    "ax = axs[1]\n",
    "spacing= .5\n",
    "for n in range(result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1]):\n",
    "    trace = result_dict['{}'.format(seq_len[ts])]['I'][t:t+dt,n]\n",
    "    mean_centered_x = (trace - np.mean(trace,axis=0))/np.max(np.abs(trace))\n",
    "    ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[-1],alpha=1)\n",
    "ts=1\n",
    "hlines_x = []\n",
    "for n in range(result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1]):\n",
    "    trace = result_dict['{}'.format(seq_len[ts])]['I_hat'][t:t+dt,n]\n",
    "    mean_centered_x = (trace - np.mean(trace,axis=0))/np.max(np.abs(trace))\n",
    "    ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c='r',alpha=.75)\n",
    "    hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "# ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "# ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "# ax.set_yticks(hlines_x[1::2])\n",
    "ax.set_yticks([])\n",
    "# ax.set_yticklabels(np.arange(2,len(hlines_x)+1,2),fontsize=fontsize-2)\n",
    "ax.set_ylabel('observations',fontsize=fontsize)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "# ax.set_ylim(-1,(1/spacing)*len(hlines_x)+.5)\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "\n",
    "\n",
    "ax = axs[2]\n",
    "dts = 1/len(seq_len)\n",
    "# timescales_M = 1/np.abs(np.real(np.log(np.linalg.eigvals(M))))[1:]\n",
    "y_ranges = np.arange(0,1,(dts*dts)).reshape(-1,len(seq_len))[:,(0,-1)]\n",
    "for ts in range(len(seq_len)):\n",
    "    # R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "    R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "    R2_hat = result_dict['{}'.format(seq_len[ts])]['R2_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R2_hat'].shape[-1])\n",
    "    I = result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1])\n",
    "\n",
    "    # ##### Plottign Eigenvalues #####\n",
    "    Uhat_all = []\n",
    "    for p in range(terrain_robot_test.shape[0]):\n",
    "        for state in range(len(np.unique(terrain_type_test))):\n",
    "            rhat2 = R_hat[np.where(terrain_robot_test[p]==state)[0],:]\n",
    "            Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "            Uhat_all.append(Uhat_0)\n",
    "            # eig_Ut = np.linalg.eigvals(Uhat_0).reshape(-1)\n",
    "            # timescales = np.real(np.log(eig_Ut))\n",
    "    Uhat_all = np.stack(Uhat_all)\n",
    "    evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "    timescales = np.real(np.log(evals_Uhat_all))\n",
    "\n",
    "    ax.scatter(x=1/np.abs(timescales),y=np.abs(evals_Uhat_all)+ts,\n",
    "            c=clrs_b[ts],alpha=.5,edgecolor='None',s=25)\n",
    "\n",
    "for ts in range(len(seq_len)):\n",
    "    ax.axhline(y=ts,c=clrs_b[ts],linestyle='--',zorder=-1)\n",
    "#     ax.axvline(x=timescales_M[n],c=sys_clrs[n])\n",
    "ax.set_xscale('symlog',linthresh=10)\n",
    "ax.set_yticks([1/2 + q for q in range(len(seq_len))])\n",
    "ax.set_yticklabels(seq_len,fontsize=fontsize-2)\n",
    "ax.set_ylabel('T',fontsize=fontsize,labelpad=-5)\n",
    "# ax.spines.left.set_visible(False)\n",
    "ax.set_xlabel('timescales',fontsize=fontsize,labelpad=-2)\n",
    "ax.set_xticks([0,10e0,10e1,10e2])\n",
    "ax.set_xlim(0,1e2)\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2, pad=-1)\n",
    "\n",
    "\n",
    "ax=axs[3]\n",
    "ax.bar(np.arange(len(f1_TiDHy)),f1_TiDHy,width=.4,color=clrs2[0])\n",
    "ax.bar(np.arange(len(f1_Inputs))+.4,f1_Inputs,width=.4,color=clrs2[4])\n",
    "ax.set_ylabel('F1 Score',fontsize=fontsize-2)\n",
    "ax.set_xticks(np.arange(.2,len(f1_TiDHy)+.2))\n",
    "ax.set_xticklabels(['difficulty','slope','velocity'],fontsize=fontsize-2)\n",
    "ax.set_yticks(np.arange(0,1.1,.25))\n",
    "ax.set_yticklabels(np.arange(0,1.1,.25),fontsize=fontsize-2)\n",
    "ax.legend(['TiDHy','Obs.'],fontsize=fontsize,frameon=False,loc='upper right',bbox_to_anchor=(1.025,1.25),labelcolor='linecolor',handlelength=0,handleheight=0,ncols=2,columnspacing=.1)\n",
    "\n",
    "ax = axs[-1]\n",
    "acc_obs = accuracy_score(terrain_type_test.reshape(-1),state_compare[0])\n",
    "acc_TiDHy = accuracy_score(terrain_type_test.reshape(-1),state_compare[1])\n",
    "_,norm = map_discrete_cbar(cmap,len(np.unique(terrain_type_test)))\n",
    "im = ax.pcolormesh(state_compare[:,t:t+dt],cmap=cmap,norm=norm,alpha=.5,rasterized=True)\n",
    "# ax.set_xticks(np.arange(0,dt+3000,3000))\n",
    "# ax.set_xticklabels(np.arange(0,dt+3000,3000),fontsize=fontsize)\n",
    "ax.set_yticks(np.arange(.5,3,1))\n",
    "ax.set_yticklabels(['Obs. \\n {:02}%'.format(int(np.round(acc_obs*100))),'TiDHy \\n {:02}%'.format(int(np.round(acc_TiDHy*100))),'True'],fontsize=fontsize-2)\n",
    "ax.set_xlabel('timesteps',fontsize=fontsize)\n",
    "\n",
    "cbar = fig.colorbar(im,ax=axs[-1],aspect=10, pad=.05)\n",
    "cbar.set_ticks(np.arange(0,len(np.unique(terrain_type_test)),1))\n",
    "cbar.set_ticklabels([''.join(terrain_names[n]) for n in range(len(terrain_names))],fontsize=fontsize-2)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2)\n",
    "\n",
    "fig.savefig(cfg.paths.fig_dir/'{}_Fig4.pdf'.format(nfig),dpi=300,transparent=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84f35936",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1,1,figsize=(5,5))\n",
    "ax = axs\n",
    "spacing= .5\n",
    "ts = -1\n",
    "hlines_x = []\n",
    "for n in range(result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1]):\n",
    "    trace = result_dict['{}'.format(seq_len[ts])]['I_hat'][t:t+dt,n]\n",
    "    mean_centered_x = (trace - np.mean(trace,axis=0))/np.max(np.abs(trace))\n",
    "    ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c='r',alpha=.75)\n",
    "    hlines_x.append(np.mean(mean_centered_x + n/spacing,axis=0))\n",
    "for n in range(result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1]):\n",
    "    trace = result_dict['{}'.format(seq_len[ts])]['I'][t:t+dt,n]\n",
    "    mean_centered_x = (trace - np.mean(trace,axis=0))/np.max(np.abs(trace))\n",
    "    ax.plot(mean_centered_x + n/spacing, lw=1,zorder=1,c=clrs_b[-1],alpha=.5)\n",
    "# ax.set_xticks(np.arange(0,t+dt+dt//4,(t+dt)//4))\n",
    "# ax.set_xticklabels(np.arange(0,t+dt+dt//4,(t+dt)//4),fontsize=fontsize-2)\n",
    "ax.set_yticks(hlines_x)\n",
    "ax.set_yticklabels(np.arange(1,len(hlines_x)+1),fontsize=fontsize-2)\n",
    "ax.set_ylabel('$\\hat{Z}$',fontsize=fontsize)\n",
    "ax.set_xlabel('time',fontsize=fontsize)\n",
    "\n",
    "\n",
    "X,Y = np.meshgrid(np.arange(0,dt),np.arange(-1,2*6))\n",
    "im = ax.pcolormesh(X,Y,np.tile(terrain_type_test[None,t:t+dt],(2*6+1,1)),cmap=cmap,norm=norm,alpha=.5,rasterized=True,zorder=-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba3ee4a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "acc_ssm = accuracy_score(terrain_type_test.reshape(-1),I_pred)\n",
    "acc_TiDHy = accuracy_score(terrain_type_test.reshape(-1),best_pred)\n",
    "_,norm = map_discrete_cbar(cmap,len(np.unique(terrain_type_test)))\n",
    "fontsize=30\n",
    "t = 0; dt = 5000\n",
    "fig,axs = plt.subplots(1,1,figsize=(10,5),sharex=True)\n",
    "ax = axs\n",
    "im = ax.pcolormesh(state_compare[:,t:t+dt],cmap=cmap,norm=norm,alpha=.5,rasterized=True)\n",
    "# ax.set_xticks(np.arange(0,dt+3000,3000))\n",
    "# ax.set_xticklabels(np.arange(0,dt+3000,3000),fontsize=fontsize)\n",
    "ax.set_yticks(np.arange(.5,3,1))\n",
    "ax.set_yticklabels(['Obs. \\n {:02}%'.format(int(np.round(acc_ssm*100))),'TiDHy \\n {:02}%'.format(int(np.round(acc_TiDHy*100))),'True'],fontsize=fontsize)\n",
    "ax.set_xlabel('Timesteps',fontsize=fontsize)\n",
    "\n",
    "# cbar = fig.colorbar(im,ax=axs,aspect=10, pad=-.2)\n",
    "cbar = add_colorbar(im,ax=axs,aspect=50, pad=.2)\n",
    "cbar.set_ticks(np.arange(.5,len(np.unique(terrain_type_test)),1))\n",
    "cbar.set_ticklabels([''.join(terrain_names[n]) for n in range(len(terrain_names))],fontsize=22)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")\n",
    "fig.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'Terrain_Classifer.pdf',dpi=300,bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c40997c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics\n",
    "f1_TiDHy = [metrics.f1_score(state_compare_best[key][-1],state_compare_best[key][1],average='weighted') for key in state_compare_best.keys()]\n",
    "f1_Inputs = [metrics.f1_score(state_compare_best[key][-1],state_compare_best[key][0],average='weighted') for key in state_compare_best.keys()]\n",
    "clrs2 =['#0F4C5C','#F4D03F','#FF6B6B','#2E8B57','#87CEEB','#778899','#40E0D0','#FFDB58','#4169E1','#C2B280','#FFDAB9','#000080','#556B2F','#008080','#FFFDD0','#B7410E','#6A5ACD','#FFBF00','#FFD1DC','#800080','#98FF98','#FA8072','#E6E6FA','#36454F']\n",
    "cmap2 = ListedColormap(clrs2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17813b9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1,1,figsize=(6,5))\n",
    "ax = axs\n",
    "ax.bar(np.arange(len(f1_TiDHy)),f1_TiDHy,width=.4,color=clrs2[0])\n",
    "ax.bar(np.arange(len(f1_Inputs))+.4,f1_Inputs,width=.4,color=clrs2[4])\n",
    "ax.set_ylabel('F1 Score',fontsize=fontsize-2)\n",
    "ax.set_xticks(np.arange(.2,len(f1_TiDHy)+.2))\n",
    "ax.set_xticklabels(['Difficulty','Slope','Velocity'],fontsize=fontsize-2)\n",
    "ax.set_yticks(np.arange(0,1.1,.25))\n",
    "ax.set_yticklabels(np.arange(0,1.1,.25),fontsize=fontsize-2)\n",
    "ax.legend(['TiDHy','Obs.'],fontsize=fontsize,frameon=False,loc='upper right',bbox_to_anchor=(1.025,1.15),labelcolor='linecolor',handlelength=0,handleheight=0,ncols=2,columnspacing=.1)\n",
    "fig.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'Terrain_Classifer_F1.pdf',dpi=300,bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab8eed0f",
   "metadata": {},
   "source": [
    "# Load CalMS21 Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "57a9cf1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAABACAYAAABsv8+/AAAAGHRFWHRUaXRsZQBmcm9tX2xpc3QgY29sb3JtYXBDL89FAAAAHnRFWHREZXNjcmlwdGlvbgBmcm9tX2xpc3QgY29sb3JtYXABtCnOAAAAMHRFWHRBdXRob3IATWF0cGxvdGxpYiB2My45LjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmdUdHMAAAAAMnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHYzLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZ3rS7CcAAAFySURBVHic7dahUQNQFABBgqYCBAYLLgYfi0oLlJFBRqQCNCINUAiFUAA4UsXnzXC7FZy8ze396+/VP/ey3U0nLPd99zGdsNzp/XM6Ybnnt5vphKUezz/TCcsdv56mE5bbHPbTCevtHqYLlrueDgAA/p4BAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABB0AdDKDH9AtJZRAAAAAElFTkSuQmCC",
      "text/html": [
       "<div style=\"vertical-align: middle;\"><strong>from_list</strong> </div><div class=\"cmap\"><img alt=\"from_list colormap\" title=\"from_list\" style=\"border: 1px solid #555;\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAgAAAABACAYAAABsv8+/AAAAGHRFWHRUaXRsZQBmcm9tX2xpc3QgY29sb3JtYXBDL89FAAAAHnRFWHREZXNjcmlwdGlvbgBmcm9tX2xpc3QgY29sb3JtYXABtCnOAAAAMHRFWHRBdXRob3IATWF0cGxvdGxpYiB2My45LjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmdUdHMAAAAAMnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHYzLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZ3rS7CcAAAFySURBVHic7dahUQNQFABBgqYCBAYLLgYfi0oLlJFBRqQCNCINUAiFUAA4UsXnzXC7FZy8ze396+/VP/ey3U0nLPd99zGdsNzp/XM6Ybnnt5vphKUezz/TCcsdv56mE5bbHPbTCevtHqYLlrueDgAA/p4BAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABBkAAAgyAAAQJABAIAgAwAAQQYAAIIMAAAEGQAACDIAABB0AdDKDH9AtJZRAAAAAElFTkSuQmCC\"></div><div style=\"vertical-align: middle; max-width: 514px; display: flex; justify-content: space-between;\"><div style=\"float: left;\"><div title=\"#1a237eff\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #1a237eff;\"></div> under</div><div style=\"margin: 0 auto; display: inline-block;\">bad <div title=\"#00000000\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #00000000;\"></div></div><div style=\"float: right;\">over <div title=\"#000000ff\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #000000ff;\"></div></div>"
      ],
      "text/plain": [
       "<matplotlib.colors.ListedColormap at 0x7d1cb8ddf2e0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "fontsize=13\n",
    "\n",
    "clrs = np.array(['#1A237E','#7E57C2','#757575','#BDBDBD','#4CAF50','#FF9800','#795548','#FF4081','#00BCD4','#FF1744','#FFFFFF','#000000'])\n",
    "sys_clrs = ['#E3A19F','#E3BE53','#708090','#90CCA9','#B7522E','#B0E0E6','#A89AC2','#556B2F','#FF6F61','#87CEEB','#FFDAB9','#40E0D0']\n",
    "cmap_sys = ListedColormap(sys_clrs)\n",
    "clr_ind =[2,2,8,8,9,9]\n",
    "# clr2 = [sys_clrs[clr_ind[n]] for n in range(len(clr_ind))]\n",
    "clr_ind3 = [2,8,9]\n",
    "clr2b = [sys_clrs[clr_ind3[n]] for n in range(len(clr_ind3))]\n",
    "\n",
    "clrs_b = clrs[[0,1,2,9,4,6,7,8,11]]\n",
    "cmap = ListedColormap(clrs)\n",
    "cmap_b = ListedColormap(clrs_b)\n",
    "cmap\n",
    "cmap_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e5a0de2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/L1ShortWin2/L1_alpha=.001/config.yaml\n",
      "1 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/L1ShortWin2/L1_alpha=.001,Orth_alpha_r2=5,dataset.train.add_basic_features=False/config.yaml\n",
      "2 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/L1ShortWin2/L1_alpha=.001,dataset.train.add_basic_features=False/config.yaml\n",
      "3 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.add_basic_features=False,dataset.train.num_epochs=1500,seed=10/config.yaml\n",
      "4 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.add_basic_features=False,dataset.train.num_epochs=1500,seed=11/config.yaml\n",
      "5 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.add_basic_features=False,dataset.train.num_epochs=1500,seed=12/config.yaml\n",
      "6 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.add_basic_features=False,dataset.train.num_epochs=1500,seed=13/config.yaml\n",
      "7 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.num_epochs=1500,seed=10/config.yaml\n",
      "8 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.num_epochs=1500,seed=11/config.yaml\n",
      "9 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.num_epochs=1500,seed=12/config.yaml\n",
      "10 /data/users/eabe/hypernets/CalMS21/TiDHy_CalMS21/r2_orth_long/Orth_alpha_r2=5,dataset.train.num_epochs=1500,seed=13/config.yaml\n"
     ]
    }
   ],
   "source": [
    "dataset = 'CalMS21'\n",
    "base_dir = Path('/data/users/eabe/hypernets/{}/TiDHy_{}/'.format(dataset,dataset))\n",
    "configs = sorted(list(base_dir.rglob('*config.yaml'))[::2])\n",
    "\n",
    "for n,conf in enumerate(configs):\n",
    "    print(n,conf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1c5bd755",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 3\n",
    "default_model_config = '/home/eabe/Research/MyRepos/HyperNets/conf/dataset/model/default_model.yaml'\n",
    "params = OmegaConf.load(default_model_config)\n",
    "cfg_path =configs[n]# Path('/data/users/eabe/hypernets/SLDS/DPC_SLDS/TestingNoTempLearning/mix_dim=15/config.yaml')\n",
    "cfg = OmegaConf.load(cfg_path)\n",
    "for k in cfg.paths.keys():\n",
    "    cfg.paths[k] = Path(cfg.paths[k])\n",
    "    cfg.paths[k].mkdir(parents=True, exist_ok=True)\n",
    "params_curr = cfg.dataset.model\n",
    "cfg.dataset.model = OmegaConf.merge(params, params_curr)\n",
    "# cfg.dataset.model['L1_inf_r2'] = 0\n",
    "# cfg.dataset.model['L1_inf_r'] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "573ce630",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating Dataset: CalMS21\n",
      "Our inputs have shape: torch.Size([1310, 200, 28])\n"
     ]
    }
   ],
   "source": [
    "# cfg.dataset.train.add_basic_features=False\n",
    "cfg.dataset.train.normalize=False\n",
    "data_dict, cfg = load_dataset(cfg)\n",
    "# ##### Convert to float tensors #####\n",
    "# test_inputs = torch.tensor(data_dict['inputs_test']).float()\n",
    "test_inputs = torch.tensor(data_dict['inputs_test']).float()\n",
    "\n",
    "input_dim = test_inputs.shape[-1]\n",
    "test_inputs = test_inputs.reshape(-1, cfg.train.sequence_length, input_dim)\n",
    "cfg.model.input_dim = input_dim\n",
    "\n",
    "print(f'Our inputs have shape: {test_inputs.shape}')\n",
    "\n",
    "test_dataset = torch.utils.data.TensorDataset(test_inputs)\n",
    "dataloader_test = torch.utils.data.DataLoader(test_dataset,batch_size=test_inputs.shape[0],pin_memory=True)\n",
    "device = torch.device(\"cuda:{}\".format(cfg.train['gpu']) if torch.cuda.is_available() else \"cpu\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fb797386",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((507600, 28), (262000, 28), (262000, 28))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_dict['inputs_train'].shape,data_dict['inputs_val'].shape, data_dict['inputs_test'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "de418971",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded from 1501 epoch\n"
     ]
    }
   ],
   "source": [
    "##### Load weights and params #####\n",
    "rerecord = False\n",
    "epoch = 1000\n",
    "model = TiDHy.TiDHy(cfg.model, device, show_progress=cfg.train.show_progress).to(device)\n",
    "# set_seed(42)\n",
    "load_path = cfg.paths.ckpt_dir/'best.pth.tar'\n",
    "# load_path = sorted(list(cfg.paths.ckpt_dir.rglob('last_{}.pth.tar'.format(epoch))))[0]\n",
    "data_load = torch.load(load_path,map_location=device)\n",
    "model.load_state_dict(data_load['state_dict'])\n",
    "model.to(device)\n",
    "print('Loaded from {} epoch'.format(data_load['epoch']))\n",
    "epoch = data_load['epoch']\n",
    "\n",
    "\n",
    "# result_dict = load_results(model, dataloader_test, data_dict, device, cfg, epoch, rerecord=rerecord)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f5b20afb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating Dataset: CalMS21\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[100, 200, 500, 1000]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_len = [100,200,500,1000]\n",
    "\n",
    "cfg, result_dict = run_seq_len_model(seq_len, model, data_dict, device, epoch, cfg, rerun=False)\n",
    "\n",
    "data_dict, cfg = load_dataset(cfg)\n",
    "seq_len = sorted([int(el) for el in list(result_dict.keys())])\n",
    "seq_len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4330153b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "183d663b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "p = -1\n",
    "pca = PCA(n_components=3)\n",
    "full_state_z = data_dict['annotations_test']\n",
    "# reg_all = np.concatenate([R2_hat,W,R_bar],axis=1)\n",
    "X_pca = pca.fit_transform(result_dict['{}'.format(seq_len[p])]['R_hat'])\n",
    "n = 0\n",
    "t = 0; dt = len(X_pca)\n",
    "X_pca = X_pca[t:t+dt]\n",
    "comps = X_pca[full_state_z==n][t:t+dt]\n",
    "ax = plt.figure().add_subplot(projection='3d')\n",
    "# ax = Axes3D(fig)\n",
    "ax.scatter(comps[:,0],comps[:,1],comps[:,2],c='r',alpha=.75)\n",
    "ax.scatter(X_pca[:,0],X_pca[:,1],X_pca[:,2],c=clrs_b[p],alpha=.01)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bb1f435",
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.io as pio\n",
    "import plotly.graph_objects as go\n",
    "pio.renderers.default = \"notebook\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80b18a67",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = -1\n",
    "pca = PCA(n_components=3)\n",
    "full_state_z = data_dict['annotations_test']\n",
    "# reg_all = np.concatenate([R2_hat,W,R_bar],axis=1)\n",
    "# X_pca = pca.fit_transform(result_dict['{}'.format(seq_len[p])]['R_hat'])\n",
    "X_pca = pca.fit_transform(result_dict['{}'.format(seq_len[p])]['R2_hat'])\n",
    "# X_pca = pca.fit_transform(R_hat)\n",
    "# X_pca = pca.fit_transform(R_bar)\n",
    "# X_pca = pca.fit_transform(reg_all)\n",
    "# X_pca = pca.fit_transform(W[:,np.sum(W,axis=0)!=0])\n",
    "# X_pca = pca.fit_transform(inputs_train)\n",
    "# X_pca = pca.fit_transform(b)\n",
    "# X_pca = pca.fit_transform(Vt.reshape(Vt.shape[0],-1))\n",
    "n = 3\n",
    "t = 0; dt = len(X_pca)\n",
    "fig = go.Figure()\n",
    "comps = X_pca[full_state_z==n][t:t+dt]\n",
    "# labels = full_state_z[full_state_z==n]\n",
    "fig.add_trace(\n",
    "    go.Scatter3d(\n",
    "        x=X_pca[:,0], y=X_pca[:,1], z=X_pca[:,2],\n",
    "        mode='markers',\n",
    "        marker=dict(\n",
    "            size=1,\n",
    "            color='black',                # set color to an array/list of desired values\n",
    "            colorscale='Viridis',   # choose a colorscale\n",
    "            opacity=.1\n",
    "        )\n",
    "    )\n",
    ")\n",
    "fig.add_trace(\n",
    "    go.Scatter3d(\n",
    "        x=comps[:,0], y=comps[:,1], z=comps[:,2],\n",
    "        mode='markers',\n",
    "        marker=dict(\n",
    "            size=2,\n",
    "            color='red',                # set color to an array/list of desired values\n",
    "            colorscale='Viridis',   # choose a colorscale\n",
    "            opacity=.01\n",
    "        )\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "fig.update_layout(\n",
    "    width=500,\n",
    "    height=500,\n",
    "    autosize=False,\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "904ab3cf",
   "metadata": {},
   "source": [
    "## Record Testset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "88393e14",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_figs = False\n",
    "ts=1\n",
    "W = result_dict['{}'.format(seq_len[ts])]['W'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['W'].shape[-1])\n",
    "# b = result_dict['{}'.format(seq_len[ts])]['b'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['b'].shape[-1])\n",
    "I = result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1])\n",
    "Ihat = result_dict['{}'.format(seq_len[ts])]['I_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I_hat'].shape[-1])\n",
    "R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "R2_hat = result_dict['{}'.format(seq_len[ts])]['R2_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R2_hat'].shape[-1])\n",
    "Ut = result_dict['{}'.format(seq_len[ts])]['Ut'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['Ut'].shape[-2],result_dict['{}'.format(seq_len[ts])]['Ut'].shape[-1])\n",
    "##### Plot dynamic matrices #####\n",
    "if cfg.model.low_rank_temp:\n",
    "    Uk = torch.bmm(model.temporal.unsqueeze(-1),model.temporal.unsqueeze(1)).data.cpu().detach()\n",
    "else:\n",
    "    Uk = model.temporal.data.cpu().detach().reshape(model.mix_dim,model.r_dim,model.r_dim)\n",
    "full_state_z = data_dict['annotations_test']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "25508806",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all 0.9827786259541985\n",
      "R2_hat 0.8604274809160305\n",
      "W 0.7668854961832061\n",
      "R_hat 0.9689618320610687\n",
      "R_bar 0.9646259541984733\n",
      "I 0.9794656488549618\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "reg_variables = [np.concatenate([R2_hat,W,R_hat],axis=-1),R2_hat,W,R_hat,R_bar,I]\n",
    "labels = ['all','R2_hat','W','R_hat','R_bar','I']\n",
    "\n",
    "# reg_variables = W\n",
    "max_acc = 0\n",
    "tr_batch_size = 40\n",
    "batch_size = 10\n",
    "for k,reg_vars in enumerate(reg_variables):\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(reg_vars.reshape(-1,reg_vars.shape[-1]), full_state_z.reshape(-1), test_size=0.25, random_state=42)\n",
    "    # X_train, X_test, y_train, y_test = train_test_split(reg_vars.reshape(-1,reg_vars.shape[-1]), terrain.reshape(-1), test_size=0.25, random_state=42)\n",
    "    neigh = KNeighborsClassifier(n_neighbors=3,n_jobs=-1)\n",
    "    neigh.fit(X_train, y_train)\n",
    "    scores = neigh.score(X_test, y_test)\n",
    "    print(labels[k],scores)\n",
    "    if (scores > max_acc) & (labels[k] != 'I'):\n",
    "        y_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "        max_acc = scores\n",
    "        best_reg_vars = reg_vars\n",
    "        best_label = labels[k]\n",
    "        best_pred = y_pred\n",
    "    else:\n",
    "        I_pred = neigh.predict(reg_vars.reshape(-1,reg_vars.shape[-1]))\n",
    "\n",
    "# plt.imshow(confusion_matrix(full_state_z, best_pred),cmap='viridis')\n",
    "# plt.colorbar()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f4d15570",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_2583984/1535938642.py:150: UserWarning: There are no gridspecs with layoutgrids. Possibly did not call parent GridSpec with the \"figure\" keyword\n",
      "  fig.savefig(cfg.paths.fig_dir / 'Fig5.pdf',dpi=300,transparent=True)\n",
      "/home/eabe/miniconda3/envs/TiDHy/lib/python3.10/site-packages/IPython/core/events.py:82: UserWarning: There are no gridspecs with layoutgrids. Possibly did not call parent GridSpec with the \"figure\" keyword\n",
      "  func(*args, **kwargs)\n",
      "/home/eabe/miniconda3/envs/TiDHy/lib/python3.10/site-packages/IPython/core/pylabtools.py:170: UserWarning: There are no gridspecs with layoutgrids. Possibly did not call parent GridSpec with the \"figure\" keyword\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 775x550 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fontsize=13\n",
    "fps = 30\n",
    "fig = plt.figure(constrained_layout=True, figsize=(7.75,5.5))\n",
    "gs  = gridspec.GridSpec(nrows=8, ncols=4,hspace=10,wspace=.5) \n",
    "gs0 = gridspec.GridSpecFromSubplotSpec(1, 4, subplot_spec=gs[:3,:],  wspace=.5,hspace=.2)\n",
    "# gsb = gridspec.GridSpecFromSubplotSpec(1, 1, subplot_spec=gs[:3,2:3], wspace=.1,hspace=.5)\n",
    "\n",
    "# gsc = gridspec.GridSpecFromSubplotSpec(1, 1, subplot_spec=gs[:5,3:], wspace=.5,hspace=.1)\n",
    "gs1 = gridspec.GridSpecFromSubplotSpec(1, 4, subplot_spec=gs[3:6,:], wspace=.2,hspace=.1)\n",
    "\n",
    "gs2 = gridspec.GridSpecFromSubplotSpec(1, 1, subplot_spec=gs[6:,:-1],   wspace=0, hspace=.10)\n",
    "\n",
    "##### plotting video frame ######\n",
    "t = 50; dt = 1\n",
    "skeleton = np.array([[0,1],[0,2],[2,3],[1,3],[3,4],[3,5],[4,6],[5,6]])\n",
    "ani1_x = data_dict['inputs_train'][t:t+dt,:7]\n",
    "ani1_y = data_dict['inputs_train'][t:t+dt,7:14]\n",
    "ani2_x = data_dict['inputs_train'][t:t+dt,14:21]\n",
    "ani2_y = data_dict['inputs_train'][t:t+dt,21:28]\n",
    "I1_x = Ihat[t:t+dt,:7]\n",
    "I1_y = Ihat[t:t+dt,7:14]\n",
    "I2_x = Ihat[t:t+dt,14:21]\n",
    "I2_y = Ihat[t:t+dt,21:28]\n",
    "labels = data_dict['annotations_train'][t:t+dt]\n",
    "clrs = plt.get_cmap('tab10',4)\n",
    "axs = np.array([fig.add_subplot(gs0[:2])])\n",
    "ax = axs[0]\n",
    "ax.imshow(frames[t])\n",
    "for n in range(7):\n",
    "    im = ax.scatter(ani1_x[:,n],ani1_y[:,n],s=10,c='#ffa600ff')\n",
    "    im = ax.scatter(ani2_x[:,n],ani2_y[:,n],s=10,c='#4daf50ff')\n",
    "tt=0\n",
    "for n in range(len(skeleton)):\n",
    "    ax.plot(ani1_x[:,skeleton[n]].squeeze(),ani1_y[:,skeleton[n]].squeeze(),'#ffa600ff',lw=2,zorder=1)\n",
    "    ax.plot(ani2_x[:,skeleton[n]].squeeze(),ani2_y[:,skeleton[n]].squeeze(),'#4daf50ff',lw=2,zorder=1)\n",
    "ax.axis('off')\n",
    "\n",
    "###### Plotting Observations #####\n",
    "axs = np.array([fig.add_subplot(gs0[2])])\n",
    "ax = axs[0]\n",
    "spacing = .75; fontsize=13\n",
    "t = 0; dt = 10000\n",
    "hlines,hlines_Ihat= [],[]\n",
    "for n in range(I.shape[-1]):\n",
    "    mean_centered = I[t:t+dt,n] - np.mean(I[t:t+dt,n],axis=0)\n",
    "    mean_centered = mean_centered\n",
    "    ax.plot(1/fps*np.arange(0,dt,1),mean_centered + n/spacing,color='k', lw=1)\n",
    "    hlines.append(np.mean(mean_centered + n/spacing,axis=0))\n",
    "    mean_centered_Ihat = Ihat[t:t+dt,n] - np.mean(Ihat[t:t+dt,n],axis=0)\n",
    "    ax.plot(1/fps*np.arange(0,dt,1),mean_centered_Ihat + n/spacing,ls='--',color='r', lw=1,zorder=2,label='Pred')\n",
    "    hlines_Ihat.append(np.mean(mean_centered_Ihat + n/spacing,axis=0))\n",
    "\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2, pad=0)\n",
    "ax.set_xlabel('time (s)',fontsize=fontsize)\n",
    "ax.set_ylabel(\"observations\",fontsize=fontsize)\n",
    "ax.set_yticks([])\n",
    "\n",
    "##### Timescales #####\n",
    "axs = np.array([fig.add_subplot(gs0[3])])\n",
    "ax = axs[0]\n",
    "dts = 1/len(seq_len)\n",
    "y_ranges = np.arange(0,1,(dts*dts)).reshape(-1,len(seq_len))[:,(0,-1)]\n",
    "for ts in range(len(seq_len)):\n",
    "    R_bar = result_dict['{}'.format(seq_len[ts])]['R_bar'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_bar'].shape[-1])\n",
    "    R_hat = result_dict['{}'.format(seq_len[ts])]['R_hat'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['R_hat'].shape[-1])\n",
    "    I = result_dict['{}'.format(seq_len[ts])]['I'].reshape(-1,result_dict['{}'.format(seq_len[ts])]['I'].shape[-1])\n",
    "\n",
    "    # ##### Plottign Eigenvalues #####\n",
    "    Uhat_all = []\n",
    "    for state in range(len(np.unique(full_state_z))):\n",
    "        rhat2 = R_hat[np.where(full_state_z==state)[0],:]\n",
    "        Uhat_0 = np.linalg.inv(rhat2[:-1].T@rhat2[:-1])@rhat2[:-1].T@rhat2[1:]\n",
    "        Uhat_all.append(Uhat_0)\n",
    "        \n",
    "    Uhat_all = np.stack(Uhat_all)\n",
    "    evals_Uhat_all = np.linalg.eigvals(Uhat_all).reshape(-1)\n",
    "    timescales = np.real(np.log(evals_Uhat_all))/fps\n",
    "\n",
    "    ax.scatter(x=1/np.abs(timescales),y=np.abs(evals_Uhat_all)+ts,c=clrs_b[ts],alpha=.5,edgecolor='None',s=25)\n",
    "\n",
    "for ts in range(len(seq_len)):\n",
    "    ax.axhline(y=ts,c=clrs_b[ts],linestyle='--',zorder=-1)\n",
    "#     ax.axvline(x=timescales_M[n],c=sys_clrs[n])\n",
    "ax.set_yticks([1/2 + q for q in range(len(seq_len))])\n",
    "ax.set_yticklabels(seq_len,fontsize=fontsize-2)\n",
    "ax.set_ylabel('T',fontsize=fontsize,labelpad=-5)\n",
    "# ax.spines.left.set_visible(False)\n",
    "ax.set_xscale('symlog',linthresh=100)\n",
    "ax.set_xlabel('timescales',fontsize=fontsize,labelpad=0)\n",
    "ax.set_xticks([10e0,10e1,10e2,10e3,10e4,10e5])\n",
    "ax.tick_params(axis='x', labelsize=fontsize-2, pad=0)\n",
    "ax.set_xlim([-1,7e4])\n",
    "\n",
    "###### PCA #####\n",
    "n = 0; m = 1\n",
    "pca = PCA()\n",
    "X_pca = pca.fit_transform(R_bar.reshape(-1,R_hat.shape[-1]))\n",
    "lst = list(itertools.combinations(np.arange(X_pca.shape[-1]), 2))\n",
    "unq = set(lst)\n",
    "axs = np.array([fig.add_subplot(gs1[n]) for n in range(4)])\n",
    "for state in range(4):\n",
    "    ax = axs[state]\n",
    "    comps = X_pca[full_state_z==state]\n",
    "    comps = comps/np.max(np.abs(comps),axis=0)\n",
    "    # comps = X_pca[(full_state_z==0) | (full_state_z==1) | (full_state_z==2)]\n",
    "    h,xedge,yedge = np.histogram2d(comps[:,n],comps[:,m],bins=50,range=[[-1,1],[-1,1]],density=True)\n",
    "    im = ax.imshow((h).T,cmap='turbo',extent=[xedge[0],xedge[-1],yedge[0],yedge[-1]],alpha=1)\n",
    "    ax.axis('square')\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.spines['bottom'].set_visible(False)\n",
    "    ax.set_title('{}'.format(list(data_dict['vocabulary'].keys())[state]),fontsize=fontsize,y=.95)\n",
    "    ax.set_xlabel('PC{}'.format(n+1),fontsize=fontsize)\n",
    "    if (state==0):\n",
    "        ax.set_ylabel('PC{}'.format(m+1),fontsize=fontsize)\n",
    "ax = axs[-1]\n",
    "cbar = fig.colorbar(im,ax=axs.flatten(),aspect=10,shrink=.5)\n",
    "cbar.set_ticks([0,np.max(h)])\n",
    "cbar.set_ticklabels(['low','high'],rotation=90)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")\n",
    "\n",
    "\n",
    "##### Behaviroal State ID #####\n",
    "t = 80000; dt = 10000; \n",
    "acc_TiDHy=accuracy_score(best_pred, full_state_z)\n",
    "# acc_TiDHy=neigh.score(I_pred, full_state_z)\n",
    "state_compare = np.stack([y_pred,full_state_z],axis=0)\n",
    "_,norm = map_discrete_cbar(cmap,len(np.unique(full_state_z)))\n",
    "axs = np.array([fig.add_subplot(gs2[n]) for n in range(1)])\n",
    "ax = axs[0]\n",
    "im = ax.pcolormesh(state_compare[:,t:t+dt],cmap=cmap,norm=norm,alpha=.5,rasterized=True)\n",
    "ax.set_yticks(np.arange(.5,2,1))\n",
    "ax.set_yticklabels(['TiDHy \\n {:02}%'.format(int(np.round(acc_TiDHy*100))),'True'],fontsize=fontsize)\n",
    "ax.set_xticks(np.arange(0,dt,60*fps))\n",
    "ax.set_xticklabels((np.arange(0,dt,60*fps)*1/fps).astype(int),fontsize=fontsize-2)\n",
    "ax.set_xlabel('time (s)',fontsize=fontsize)\n",
    "\n",
    "# plt.tight_layout()\n",
    "cbar = fig.colorbar(im,ax=axs.flatten(),aspect=10, pad=.01)\n",
    "\n",
    "cbar.set_ticks(np.arange(0,len(np.unique(full_state_z)),1))\n",
    "cbar.set_ticklabels(list(data_dict['vocabulary'].keys()),fontsize=fontsize)\n",
    "cbar.outline.set_linewidth(1)\n",
    "cbar.minorticks_off()\n",
    "cbar.ax.tick_params(width=1,which=\"major\")\n",
    "\n",
    "fig.savefig(cfg.paths.fig_dir / 'Fig5.pdf',dpi=300,transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b45550f",
   "metadata": {},
   "outputs": [],
   "source": [
    "spacing = .1; fontsize=13\n",
    "t = 0; dt = 10000\n",
    "cmap,norm = map_discrete_cbar('tab10',len(np.unique(full_state_z)))\n",
    "fig,axs = plt.subplots(1,1,figsize=(2,3))\n",
    "\n",
    "ax = axs\n",
    "hlines,hlines_Ihat= [],[]\n",
    "for n in range(I.shape[-1]):\n",
    "    mean_centered = I[t:t+dt,n] - np.mean(I[t:t+dt,n],axis=0)\n",
    "    mean_centered = mean_centered\n",
    "    ax.plot(1/fps*np.arange(0,dt,1),mean_centered + n/spacing,color='k', lw=1)\n",
    "    hlines.append(np.mean(mean_centered + n/spacing,axis=0))\n",
    "    mean_centered_Ihat = Ihat[t:t+dt,n] - np.mean(Ihat[t:t+dt,n],axis=0)\n",
    "    ax.plot(1/fps*np.arange(0,dt,1),mean_centered_Ihat + n/spacing,ls='--',color='r', lw=1,zorder=2,label='Pred')\n",
    "    hlines_Ihat.append(np.mean(mean_centered_Ihat + n/spacing,axis=0))\n",
    "\n",
    "ax.set_xlabel('time (s)',fontsize=fontsize)\n",
    "ax.set_ylabel(\"Observations\",fontsize=fontsize)\n",
    "ax.set_yticks([])\n",
    "plt.tight_layout()\n",
    "# fig.savefig(cfg.paths.fig_dir/'CalMS21_Observations.pdf',dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 \n",
    " \n",
    "# Create a VideoCapture object and read from input file\n",
    "# If the input is the camera, pass 0 instead of the video file name\n",
    "cap = cv2.VideoCapture('/data/users/eabe/hypernets/CalMS21/datasets/mouse001_task1_annotator1.mp4')\n",
    " \n",
    "# Check if camera opened successfully\n",
    "if (cap.isOpened()== False): \n",
    "  print(\"Error opening video stream or file\")\n",
    " \n",
    "# Read until video is completed\n",
    "frames = []\n",
    "while(cap.isOpened()):\n",
    "  # Capture frame-by-frame\n",
    "  ret, frame = cap.read()\n",
    "  if ret == True:\n",
    "    frames.append(frame)   \n",
    "  # Break the loop\n",
    "  else: \n",
    "    break\n",
    " \n",
    "# When everything done, release the video capture object\n",
    "cap.release()\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41097339",
   "metadata": {},
   "source": [
    "## Animations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41097339",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ray\n",
    "import time\n",
    "import cv2\n",
    "import gc\n",
    "mpl.use('agg')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f684e988",
   "metadata": {},
   "outputs": [],
   "source": [
    "@ray.remote\n",
    "def make_plt_im(t, X_pca,data_dict,full_state_z):   #\n",
    "    trail = 5\n",
    "    labels = full_state_z[t-trail:t+1]\n",
    "    cmap = plt.get_cmap('tab10',len(np.unique(full_state_z)))\n",
    "    bounds = np.arange(len(np.unique(full_state_z))+1)\n",
    "    norm = mpl.colors.BoundaryNorm(bounds, cmap.N)\n",
    "\n",
    "    fig,axs = plt.subplots(1,3,figsize=(15,5))\n",
    "    ax = axs[0]\n",
    "    im = ax.scatter(X_pca[:,0],X_pca[:,1],s=1,c='k',alpha=.01)\n",
    "    im = ax.scatter(X_pca[t-trail:t+1,0],X_pca[t-trail:t+1,1],s=3,c=labels,cmap=cmap,norm=norm,alpha=1)\n",
    "    ax.axis('square')\n",
    "    ax.set_xlim([-1,1])\n",
    "    ax.set_ylim([-1,1])\n",
    "    cbar = fig.colorbar(im, ax=axs,location='right')\n",
    "    cbar.set_ticks(np.arange(.5,len(np.unique(full_state_z)),1))\n",
    "    cbar.set_ticklabels(np.arange(-1,len(np.unique(full_state_z))-1,1))\n",
    "    ax.set_title('Rbar PCA comps')\n",
    "\n",
    "\n",
    "    ani1_x = data_dict['inputs_test'][t-trail:t+1,:7]\n",
    "    ani1_y = data_dict['inputs_test'][t-trail:t+1,7:14]\n",
    "    ani2_x = data_dict['inputs_test'][t-trail:t+1,14:21]\n",
    "    ani2_y = data_dict['inputs_test'][t-trail:t+1,21:28]\n",
    "    labels = data_dict['annotations_test'][t-trail:t+1]\n",
    "    for n in range(7):\n",
    "        ax = axs[1]\n",
    "        im = ax.scatter(ani1_x[:,n],ani1_y[:,n],s=1,c=labels,cmap=cmap,norm=norm,)\n",
    "        ax.axis('square')\n",
    "        ax.set_xlim([0,1])\n",
    "        ax.set_ylim([0,1])\n",
    "        ax.set_title('Mouse 1')\n",
    "        ax = axs[2]\n",
    "        ax.scatter(ani2_x[:,n],ani2_y[:,n],s=1,c=labels,cmap=cmap,norm=norm,)\n",
    "        ax.axis('square')\n",
    "        ax.set_xlim([0,1])\n",
    "        ax.set_ylim([0,1])\n",
    "        ax.set_title('Mouse 2')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    width, height = fig.get_size_inches() * fig.get_dpi()\n",
    "    fig.canvas.draw()       # draw the canvas, cache the renderer\n",
    "    images = np.frombuffer(fig.canvas.tostring_rgb(),\n",
    "                        dtype='uint8').reshape(int(height), int(width), 3)\n",
    "    plt.close()\n",
    "    return images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8e9cb47",
   "metadata": {},
   "outputs": [],
   "source": [
    "# images = make_plt_im(t, X_pca,data_dict)\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca = PCA(n_components=3)\n",
    "\n",
    "# full_state_z = data_dict['annotations_test']\n",
    "full_state_z = cluster_labels\n",
    "X_pca = pca.fit_transform(R_bar)\n",
    "\n",
    "t = 80000; dt = 5000\n",
    "trail = 5\n",
    "labels = full_state_z[t-trail:t+1]\n",
    "cmap = plt.get_cmap('tab10',len(np.unique(full_state_z)))\n",
    "bounds = np.arange(len(np.unique(full_state_z))+1)\n",
    "norm = mpl.colors.BoundaryNorm(bounds, cmap.N)\n",
    "\n",
    "fig,axs = plt.subplots(1,3,figsize=(15,5))\n",
    "ax = axs[0]\n",
    "im = ax.scatter(X_pca[:,0],X_pca[:,1],s=1,c='k',alpha=.01)\n",
    "im = ax.scatter(X_pca[t-trail:t+1,0],X_pca[t-trail:t+1,1],s=3,c=labels,cmap=cmap,norm=norm,alpha=1)\n",
    "ax.axis('square')\n",
    "ax.set_xlim([-1,1])\n",
    "ax.set_ylim([-1,1])\n",
    "cbar = fig.colorbar(im, ax=axs,location='right')\n",
    "cbar.set_ticks(np.arange(.5,len(np.unique(full_state_z)),1))\n",
    "cbar.set_ticklabels(np.arange(-1,len(np.unique(full_state_z))-1,1))\n",
    "ax.set_title('Rbar PCA comps')\n",
    "\n",
    "\n",
    "ani1_x = data_dict['inputs_test'][t-trail:t+1,:7]\n",
    "ani1_y = data_dict['inputs_test'][t-trail:t+1,7:14]\n",
    "ani2_x = data_dict['inputs_test'][t-trail:t+1,14:21]\n",
    "ani2_y = data_dict['inputs_test'][t-trail:t+1,21:28]\n",
    "labels = data_dict['annotations_test'][t-trail:t+1]\n",
    "for n in range(7):\n",
    "    ax = axs[1]\n",
    "    im = ax.scatter(ani1_x[:,n],ani1_y[:,n],s=1,c=labels,cmap=cmap,norm=norm,)\n",
    "    ax.axis('square')\n",
    "    ax.set_xlim([0,1])\n",
    "    ax.set_ylim([0,1])\n",
    "    ax.set_title('Mouse 1')\n",
    "    ax = axs[2]\n",
    "    ax.scatter(ani2_x[:,n],ani2_y[:,n],s=1,c=labels,cmap=cmap,norm=norm,)\n",
    "    ax.axis('square')\n",
    "    ax.set_xlim([0,1])\n",
    "    ax.set_ylim([0,1])\n",
    "    ax.set_title('Mouse 2')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "fig.savefig(cfg.paths.fig_dir/'test.png',dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a153f345",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(cluster_labels==2)[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "960c7889",
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "##### initialize time points for animation and progressbar #####\n",
    "t = 0 ; dt = 10000\n",
    "full_state_z = cluster_labels\n",
    "state = 'I'\n",
    "time_range = np.arange(t,t+dt)#  np.where(cluster_labels==state)[0]#\n",
    "num_ticks = np.size(time_range)\n",
    "pca = PCA(n_components=3)\n",
    "X_pca = pca.fit_transform(I)\n",
    "\n",
    "##### Put large arrays into shared memory #####\n",
    "X_pca_r = ray.put(X_pca)\n",
    "data_dict_r = ray.put(data_dict)\n",
    "full_state_z_r = ray.put(full_state_z)\n",
    "##### Loop over parameters appending process ids #####\n",
    "result_ids = []\n",
    "for t in time_range:\n",
    "    result_ids.append(make_plt_im.remote(t, X_pca_r, data_dict_r,full_state_z_r))\n",
    "\n",
    "##### pring progressbar and get results #####\n",
    "results_p = ray.get(result_ids)\n",
    "images = np.stack([results_p[i] for i in range(len(results_p))])\n",
    "\n",
    "##### Make video with opencv #####\n",
    "aniname = 'PCA_Evolve_{}.mp4'.format(state) \n",
    "\n",
    "\n",
    "vid_name = cfg.paths.fig_dir / aniname\n",
    "FPS = 30\n",
    "out = cv2.VideoWriter(vid_name.as_posix(), cv2.VideoWriter_fourcc(*'mp4v'), FPS, (images.shape[-2], images.shape[-3]))\n",
    "\n",
    "for fm in tqdm(range(images.shape[0])):\n",
    "    out.write(cv2.cvtColor(images[fm], cv2.COLOR_BGR2RGB))\n",
    "out.release()\n",
    "print('Making Animation {}: {}'.format(aniname, time.time()-start))\n",
    "del results_p, X_pca_r, data_dict_r, full_state_z_r\n",
    "gc.collect()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e0c4218",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 80000 ; dt = 5000\n",
    "labels = full_state_z[t:t+dt]\n",
    "cmap = plt.get_cmap('tab10',len(np.unique(full_state_z)))\n",
    "bounds = np.arange(len(np.unique(full_state_z))+1)\n",
    "norm = mpl.colors.BoundaryNorm(bounds, cmap.N)\n",
    "\n",
    "fig,axs = plt.subplots(1,3,figsize=(15,5))\n",
    "ax = axs[0]\n",
    "im = ax.scatter(X_pca[t:t+dt,0],X_pca[t:t+dt,1],s=1,c=labels,cmap=cmap,norm=norm,alpha=1)\n",
    "ax.axis('square')\n",
    "ax.set_xlim([-1,1])\n",
    "ax.set_ylim([-1,1])\n",
    "cbar = fig.colorbar(im, ax=axs,location='right')\n",
    "cbar.set_ticks(np.arange(.5,4,1))\n",
    "cbar.set_ticklabels(list(data_dict['vocabulary'].keys()))\n",
    "ax.set_title('Rbar PCA comps')\n",
    "\n",
    "\n",
    "ani1_x = data_dict['inputs_test'][t:t+dt,:7]\n",
    "ani1_y = data_dict['inputs_test'][t:t+dt,7:14]\n",
    "ani2_x = data_dict['inputs_test'][t:t+dt,14:21]\n",
    "ani2_y = data_dict['inputs_test'][t:t+dt,21:28]\n",
    "labels = data_dict['annotations_test'][t:t+dt]\n",
    "clrs = plt.get_cmap('tab10',4)\n",
    "for n in range(7):\n",
    "    ax = axs[1]\n",
    "    im = ax.scatter(ani1_x[:,n],ani1_y[:,n],s=1,c=labels,cmap=clrs)\n",
    "    ax.set_xlim([0,1])\n",
    "    ax.set_ylim([0,1])\n",
    "    ax.axis('square')\n",
    "    ax.set_title('Mouse 1')\n",
    "    ax = axs[2]\n",
    "    ax.scatter(ani2_x[:,n],ani2_y[:,n],s=1,c=labels,cmap=clrs)\n",
    "    ax.axis('square')\n",
    "    ax.set_xlim([0,1])\n",
    "    ax.set_ylim([0,1])\n",
    "    ax.set_title('Mouse 2')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbfeb3aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pca = PCA()\n",
    "\n",
    "# X_pca = pca.fit_transform(R_bar)\n",
    "from sklearn.mixture import GaussianMixture\n",
    "from sklearn.cluster import KMeans, HDBSCAN\n",
    "from sklearn.model_selection import train_test_split\n",
    "reg_variables = [R2_hat]#[np.concatenate([R2_hat,W,R_hat],axis=1),R2_hat,W,R_hat]\n",
    "\n",
    "X_train, X_test = train_test_split(R_bar, test_size=0.75, random_state=42)\n",
    "\n",
    "# kmeans = KMeans(n_clusters=5, random_state=0).fit(X_pca)\n",
    "# clusterer = hdbscan.HDBSCAN(min_cluster_size=5,core_dist_n_jobs=-1,prediction_data=True)\n",
    "# clusterer.fit(R_bar)\n",
    "# cluster_labels = HDBSCAN(min_cluster_size=5,min_samples=100,cluster_selection_epsilon=.001,leaf_size=1000,n_jobs=-1).fit_predict(reg_variables[0])\n",
    "# cluster_labels = clusterer.labels_\n",
    "# clusters = GaussianMixture(n_components=5, random_state=0).fit(R_bar)\n",
    "# labels = full_state_z\n",
    "# labels = hbdscan.labels_\n",
    "# print(np.unique(cluster_labels,return_counts=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfab14f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsTransformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f660675c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# kmeans = KMeans(n_clusters=5, random_state=0).fit(X_train)\n",
    "# kmeans = KMeans(n_clusters=5, random_state=0).fit(X_train)\n",
    "cluster = KNeighborsTransformer(n_neighbors=5).fit(X_train)\n",
    "A = cluster.kneighbors_graph(X_test).toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28894747",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5701c511",
   "metadata": {},
   "outputs": [],
   "source": [
    "# X_pca = pca.fit_transform(result_dict['{}'.format(seq_len[p])]['R2_hat'])\n",
    "X_pca = pca.fit_transform(R_bar)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "596086a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.unique(labels,return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5485c715",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(X_pca[:,0],X_pca[:,1],c=labels,alpha=.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ac28235",
   "metadata": {},
   "source": [
    "# Neural Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78a46a45",
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.io as sio\n",
    "import json\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80321a85",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "zfish_data = sio.loadmat('/data/users/eabe/hypernets/Zfish/datasets/zArchonData20210305.mat')\n",
    "zfish_data = zfish_data['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e851437f",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "traces = np.stack([zfish_data['trace'][0,n] for n in range(zfish_data.shape[-1])]).squeeze()\n",
    "traces.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db7fe89a",
   "metadata": {},
   "outputs": [],
   "source": [
    "nan_x,nan_y = np.where(np.isnan(traces))\n",
    "traces2 = np.delete(traces,nan_x,axis=0)\n",
    "unique_nan = np.unique(nan_x)\n",
    "fish_N = [np.where(zfish_data['fishId']==n)[1] for n in range(1,11)]\n",
    "fish_N = np.array([np.array([fish_N[n][i] for i  in range(len(fish_N[n])) if i not in unique_nan]) for n in range(len(fish_N))],dtype=object)\n",
    "# np.unique(x,return_counts=True),np.unique(y,return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96d2b19d",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.unique(np.hstack(fish_N)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1f9a93b",
   "metadata": {},
   "outputs": [],
   "source": [
    "traces2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6fb0cba",
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = PCA(n_components=3)\n",
    "X_pca = pca.fit_transform(traces2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e473cab7",
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_nan.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5595359e",
   "metadata": {},
   "outputs": [],
   "source": [
    "fish_id = np.hstack([(n)*np.ones(fish_N[n].shape) for n in range(len(fish_N))])\n",
    "X_pca.shape,fish_id.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72983067",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(X_pca[:,0],X_pca[:,1],s=1,c=fish_id,alpha=1)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6650f04",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(traces[500:510,:].T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "116a1e03",
   "metadata": {},
   "outputs": [],
   "source": [
    "zfish_data.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "509e4682",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adf01163",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.max(np.hstack(fish_N))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "187610b7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe12e81c",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.unique(zfish_data['fishId']==1,return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68c0eb15",
   "metadata": {},
   "outputs": [],
   "source": [
    "zfish_data['trial'].squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3735ccc",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "data_dir = Path('/data/users/eabe/hypernets/WormDataset/datasets/')\n",
    "data_list = sorted(list(data_dir.glob('*.json')))\n",
    "\n",
    "\n",
    "data_worm_all = {}\n",
    "for n in range(len(data_list)):\n",
    "    with open(data_list[n]) as f:\n",
    "        worm_data = json.load(f)\n",
    "    data_worm_all[data_list[n].stem] = worm_data\n",
    "    \n",
    "trace_array_all = []\n",
    "for key1 in data_worm_all.keys():\n",
    "    trace_array_all.append(np.stack(data_worm_all[key1]['trace_array']))\n",
    "# trace_array_all = np.stack(trace_array_all)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a1b3bc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "key1 = list(data_worm_all.keys())[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de29822b",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(data_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7385ab33",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels_all = []\n",
    "for key1 in data_worm_all.keys():\n",
    "    temp_label = []\n",
    "    for key2 in data_worm_all[key1]['labeled'].keys():\n",
    "        if (data_worm_all[key1]['labeled'][key2]['label'] in high_labels):\n",
    "            temp_label.append(data_worm_all[key1]['labeled'][key2]['label'])\n",
    "    print(len(temp_label))\n",
    "    labels_all.append(temp_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e950f7a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = list(set.intersection(*map(set, labels_all)))\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c74907ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = np.array([data_worm_all[key1]['labeled'][key2]['label'] for key1 in data_worm_all.keys() for key2 in data_worm_all[key1]['labeled'].keys() ])\n",
    "unique_labels, ids, counts = np.unique(labels,return_inverse=True,return_counts=True)\n",
    "\n",
    "low_labels = unique_labels[counts<35]\n",
    "high_labels = unique_labels[counts>35]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dae5b7d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "low_labels,high_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d19874c1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d90bf31",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35d9b364",
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.unique(labels,return_counts=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b298a056",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(unique_labels[1]==labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11a1a43f",
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_labels.shape, ids.shape,counts.shape,labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11f5281b",
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c7c0fc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "dl = pd.factorize(labels)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3b6006c",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(labels==common_labels[0])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8365c2fb",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "TiDHy",
   "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}