NOVEMBER_Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import os\n",
    "import cv2\n",
    "import imageio\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import ListedColormap\n",
    "import seaborn as sns\n",
    "import torch\n",
    "import cmath\n",
    "from run_VAE import sites_NOVEMBER, RAW_NOVEMBER, INTERMEDIATE_NOVEMBER\n",
    "from HiddenStateExtractor.cv2_feature import get_density, get_angle_apr, get_aspect_ratio_no_rotation\n",
    "from HiddenStateExtractor.vq_vae import VQ_VAE, rescale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "RAW_NOVEMBER = '/mnt/comp_micro/Projects/learningCellState/microglia/raw_for_segmentation/NOVEMBER/raw'\n",
    "INTERMEDIATE_NOVEMBER = '/mnt/comp_micro/Projects/learningCellState/microglia/raw_for_segmentation/NOVEMBER/supp'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.switch_backend('module://ipykernel.pylab.backend_inline')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Define Extra Functions ###\n",
    "\n",
    "phase_a = 2.\n",
    "phase_b = -50000.\n",
    "\n",
    "sites = sites_NOVEMBER\n",
    "# {'B4', 'B5', 'C4', 'B2', 'C5'}\n",
    "wells = {'B4', 'B5', 'B2', 'C5', 'C4'}\n",
    "wells_ = {'B4', 'B5', 'B2', 'C5'}\n",
    "raw_folder = RAW_NOVEMBER\n",
    "supp_folder = INTERMEDIATE_NOVEMBER\n",
    "\n",
    "legends = {\n",
    "    'B2': 'GBM',\n",
    "    'B4': 'IL17',\n",
    "    'B5': 'IFN beta',\n",
    "    'C4': 'Rubella',\n",
    "    'C5': 'Control'\n",
    "}\n",
    "\n",
    "def hex_to_rgb(s):\n",
    "    s = s.lstrip('#')\n",
    "    s = list(int(s[i:i+2], 16)/256. for i in (0, 2, 4)) + [1.] # hex to rgb\n",
    "    return s\n",
    "\n",
    "def rgb_to_hex(rgb):\n",
    "    return '#%02x%02x%02x' % rgb\n",
    "\n",
    "def generate_color_vectors(start, end, N=256):\n",
    "    start = hex_to_rgb(start)\n",
    "    end = hex_to_rgb(end)\n",
    "    output = np.zeros((N, 4))\n",
    "    for i in range(4):\n",
    "        output[:, i] = np.linspace(start[i], end[i], N)\n",
    "    return output\n",
    "\n",
    "cmaps = {\n",
    "    'B2': ListedColormap(generate_color_vectors('#ffffff', '#438548')),\n",
    "    'B4': ListedColormap(generate_color_vectors('#ffffff', '#ce103d')),\n",
    "    'B5': ListedColormap(generate_color_vectors('#ffffff', '#d44d00')),\n",
    "    'C4': ListedColormap(generate_color_vectors('#ffffff', '#f0ba00')),\n",
    "    'C5': ListedColormap(generate_color_vectors('#ffffff', '#005082')),\n",
    "    'all': ListedColormap(generate_color_vectors('#ffffff', '#111111'))\n",
    "}\n",
    "\n",
    "colors = {w: cmaps[w](0.8) for w in cmaps}\n",
    "\n",
    "def enhance_contrast(mat, a=1.5, b=-10000):\n",
    "  mat2 = cv2.addWeighted(mat, a, mat, 0, b)\n",
    "  return mat2\n",
    "\n",
    "def save_movie(traj, path):\n",
    "  well = traj[:2]\n",
    "  site = traj.split('/')[0]\n",
    "  stacks = []\n",
    "  for ind in traj_inds[traj]:\n",
    "    f = fs[well][ind]\n",
    "    p = os.path.join(supp_folder, '%s-supps' % well, '%s' % site, 'stacks_%s.pkl' % f.split('/')[-1].split('_')[0])\n",
    "    mat = pickle.load(open(p, 'rb'))[f]['mat'][:, :, 0]\n",
    "    mat2 = np.clip(enhance_contrast(mat, phase_a, phase_b), 0, 65535).astype('uint16')\n",
    "    stacks.append(mat2)\n",
    "  output = (np.stack(stacks, 0).astype('float')/256).astype('uint8')\n",
    "  imageio.mimsave(path, output)\n",
    "\n",
    "def save_traj_bbox(traj, path):\n",
    "  output_images = np.zeros((len(traj_inds[traj]), 512, 512))\n",
    "  site = traj.split('/')[0]\n",
    "  image_stack = np.load(os.path.join(raw_folder, '%s.npy' % site))\n",
    "  for i, k in enumerate(sorted(trajs[traj].keys())):\n",
    "    mat = cv2.resize(image_stack[k, :, :, 0], (512, 512))\n",
    "    output_images[i] = np.clip(enhance_contrast(mat, phase_a, phase_b), 0, 65535).astype('uint16')\n",
    "\n",
    "  output_images = np.stack([output_images] * 3, 3)\n",
    "  output_images = output_images / 65535.\n",
    "\n",
    "  for i, k in enumerate(sorted(trajs[traj].keys())):\n",
    "    box_center = traj_positions[traj][k] / (2048/512)\n",
    "    box_range = [(max(box_center[0] - 16., 0), min(box_center[0] + 16., 512)),\n",
    "                 (max(box_center[1] - 16., 0), min(box_center[1] + 16., 512))]\n",
    "    \n",
    "    # Left edge\n",
    "    x = box_range[0][0]\n",
    "    x_ = (int(max(x - 1., 0)), int(min(x + 1., 512)))\n",
    "    output_images[i, x_[0]:x_[1], int(box_range[1][0]):int(box_range[1][1])] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "    # Right edge\n",
    "    x = box_range[0][1]\n",
    "    x_ = (int(max(x - 1., 0)), int(min(x + 1., 512)))\n",
    "    output_images[i, x_[0]:x_[1], int(box_range[1][0]):int(box_range[1][1])] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "    # Top edge\n",
    "    y = box_range[1][0]\n",
    "    y_ = (int(max(y - 1., 0)), int(min(y + 1., 512)))\n",
    "    output_images[i, int(box_range[0][0]):int(box_range[0][1]), y_[0]:y_[1]] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "    # Bottom edge\n",
    "    y = box_range[1][1]\n",
    "    y_ = (int(max(y - 1., 0)), int(min(y + 1., 512)))\n",
    "    output_images[i, int(box_range[0][0]):int(box_range[0][1]), y_[0]:y_[1]] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "  # tifffile.imwrite(path, (output_images*255).astype('uint8'))\n",
    "  imageio.mimwrite(path, (output_images*255).astype('uint8'))\n",
    "  return\n",
    "\n",
    "def plot_joint_density(x, y, df, bins_x, bins_y, cmap='Blues'):\n",
    "    g = sns.JointGrid(x=x, y=y, data=df, ylim=(bins_y[0], bins_y[-1]), xlim=(bins_x[0], bins_x[-1]))\n",
    "    _ = g.ax_marg_x.hist(df[x], bins=bins_x, color=cmap(0.8))\n",
    "    _ = g.ax_marg_y.hist(df[y], bins=bins_y, orientation='horizontal', color=cmap(0.8))\n",
    "    g.plot_joint(plt.hexbin, cmap=cmap, gridsize=len(bins_x))\n",
    "\n",
    "def plot_joint_kde(x, y, df, bins_x, bins_y, cmap='Blues'):\n",
    "    g = sns.JointGrid(x=x, y=y, data=df, ylim=(bins_y[0], bins_y[-1]), xlim=(bins_x[0], bins_x[-1]))\n",
    "    _ = g.ax_marg_x.hist(df[x], bins=bins_x, color=cmap(0.8))\n",
    "    _ = g.ax_marg_y.hist(df[y], bins=bins_y, orientation='horizontal', color=cmap(0.8))\n",
    "    g.plot_joint(sns.kdeplot, cmap=cmap, shade=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Load All Data ###\n",
    "# dats = {}\n",
    "# fs = {}\n",
    "# traj_inds = {}\n",
    "# trajs = {}\n",
    "# traj_positions = {}\n",
    "# for well in wells:\n",
    "#     path = os.path.join(raw_folder, '%s_latent_space_PCAed.pkl' % well)\n",
    "#     dats[well] = pickle.load(open(path, 'rb'))\n",
    "    \n",
    "#     path = os.path.join(raw_folder, '%s_file_paths.pkl' % well)\n",
    "#     fs[well] = pickle.load(open(path, 'rb'))\n",
    "\n",
    "#     well_sites = [s for s in sites if s.startswith(well)]\n",
    "#     for site in well_sites:\n",
    "#         print(site)\n",
    "#         path = os.path.join(supp_folder, '%s-supps' % well, '%s' % site, 'cell_traj.pkl')\n",
    "#         cell_trajectories_inds, cell_trajectories_positions = pickle.load(open(path, 'rb'))\n",
    "\n",
    "#         path = os.path.join(supp_folder, '%s-supps' % well, '%s' % site, 'cell_pixel_assignments.pkl')\n",
    "#         cell_pixel_assignments = pickle.load(open(path, 'rb'))\n",
    "\n",
    "#         path = os.path.join(raw_folder, '%s_NNProbabilities.npy' % site)\n",
    "#         segmentation_stack = np.load(path)\n",
    "\n",
    "#         for i, (t, t_pos) in enumerate(zip(cell_trajectories_inds, cell_trajectories_positions)):\n",
    "#             traj_mg_ratios = []\n",
    "#             for t_point in t:\n",
    "#                 cell_id = t[t_point]\n",
    "#                 inds = np.where(cell_pixel_assignments[t_point][1] == cell_id)\n",
    "#                 cell_pixels = cell_pixel_assignments[t_point][0][inds]\n",
    "#                 cell_segmentation = segmentation_stack[t_point][(cell_pixels[:, 0], cell_pixels[:, 1])]\n",
    "#                 mg_ratio = (cell_segmentation[:, 1] > 0.5).sum() / cell_segmentation.shape[0]\n",
    "#                 traj_mg_ratios.append(mg_ratio)\n",
    "#             if np.percentile(traj_mg_ratios, 0.2) > 0.8:\n",
    "#                 # Confirmed as microglia\n",
    "#                 trajs[site + '/%d' % i] = t\n",
    "#                 traj_positions[site + '/%d' % i] = t_pos\n",
    "\n",
    "#     path = os.path.join(raw_folder, '%s_trajectories.pkl' % well)\n",
    "#     well_traj_inds = pickle.load(open(path, 'rb'))\n",
    "#     traj_inds.update({k: v for k, v in well_traj_inds.items() if k in trajs})\n",
    "\n",
    "# with open('NOVEMBER_dat_save.pkl', 'wb') as f:\n",
    "#     pickle.dump([dats, fs, traj_inds, trajs, traj_positions], f)\n",
    "\n",
    "dats, fs, traj_inds, trajs, traj_positions = pickle.load(open('NOVEMBER_dat_save.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Load All RAW Data ###\n",
    "all_patches = {}\n",
    "for well in wells:\n",
    "    print(well)\n",
    "    site_dat = torch.load(os.path.join(raw_folder, '%s_adjusted_static_patches.pt' % well))\n",
    "    site_dat = rescale(site_dat)\n",
    "    for i, f in enumerate(fs[well]):\n",
    "        all_patches[f] = site_dat[i:(i+1)][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Process Data and Generate Trajectory Summaries ###\n",
    "\n",
    "t_lag = 1\n",
    "bins_PC1 = np.linspace(-4, 6, 20)\n",
    "bins_PC2 = np.linspace(-3, 8, 20)\n",
    "bins_speed = np.linspace(1.0, 5.2, 20) # Log um/h scale\n",
    "\n",
    "patch_PC1 = {well: dats[well][:, 0] for well in wells}\n",
    "patch_PC2 = {well: dats[well][:, 1] for well in wells}\n",
    "\n",
    "traj_PC1 = {well: [] for well in wells}\n",
    "traj_PC2 = {well: [] for well in wells}\n",
    "traj_speed = {well: [] for well in wells}\n",
    "traj_names = {well: [] for well in wells}\n",
    "for t in trajs:\n",
    "    well = t[:2]\n",
    "    if not well in wells:\n",
    "        continue\n",
    "    traj_names[well].append(t)\n",
    "    traj_PC1[well].append(np.mean([dats[well][ind, 0] for ind in traj_inds[t]]))\n",
    "    traj_PC2[well].append(np.mean([dats[well][ind, 1] for ind in traj_inds[t]]))\n",
    "\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    dists = []\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            dists.append(d)    \n",
    "    traj_speed[well].append(np.log(np.mean(dists) * 0.325 / 0.1518)) # Unit of pixel(0.325um) per frame(9.11 min) to um per hour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### PCA of traj vectors ###\n",
    "from sklearn.decomposition import PCA\n",
    "ts = sorted(trajs.keys())\n",
    "traj_vectors = np.stack([traj_vector_latent_vector[t] for t in ts], 0)\n",
    "pca = PCA(0.5)\n",
    "pcaed = pca.fit_transform(traj_vectors)\n",
    "\n",
    "well_inds = {w: [] for w in wells}\n",
    "for i,t in enumerate(ts):\n",
    "    well_inds[t[:2]].append(i)\n",
    "for w in well_inds:\n",
    "    well_inds[w] = np.array(well_inds[w])\n",
    "    \n",
    "fig, axs = plt.subplots(3, 2, figsize=(8, 12))\n",
    "\n",
    "axs[-1][-1].hexbin(pcaed[:, 0], \n",
    "                   pcaed[:, 1], \n",
    "                   gridsize=20, \n",
    "                   extent=(-11, 16, -11, 16),\n",
    "                   cmap=cmaps['all'])\n",
    "axs[-1][-1].set_xlim(-11, 16)\n",
    "axs[-1][-1].set_ylim(-12, 16)\n",
    "axs[-1][-1].set_yticks([-10, 0, 10])\n",
    "axs[-1][-1].set_xticks([-10, 0, 10])\n",
    "for i, w in enumerate(sorted(wells)):\n",
    "    axs[i//2][i%2].hexbin(pcaed[:, 0][well_inds[w]], \n",
    "                          pcaed[:, 1][well_inds[w]], \n",
    "                          gridsize=20, \n",
    "                          extent=(-11, 16, -11, 16),\n",
    "                          cmap=cmaps[w])\n",
    "    axs[i//2][i%2].set_xlim(-11, 16)\n",
    "    axs[i//2][i%2].set_ylim(-12, 16)\n",
    "    axs[i//2][i%2].set_yticks([-10, 0, 10])\n",
    "    axs[i//2][i%2].set_xticks([-10, 0, 10])\n",
    "    axs[i//2][i%2].text(-10, 11, legends[w])\n",
    "# plt.show()\n",
    "plt.savefig('traj_vec_rand_samples_pre_pca.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Calculate Cell Motion Directions ###\n",
    "\n",
    "cell_aps = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_aspect_ratios.pkl'), 'rb'))\n",
    "traj_orientations = {}\n",
    "traj_orientations2 = {}\n",
    "traj_orientation_stds = {}\n",
    "patch_orientations = {}\n",
    "patch_displacements = {}\n",
    "t_lag = 1\n",
    "\n",
    "angs1_all = []\n",
    "angs2_all = []\n",
    "ang_diffs_all = []\n",
    "for t in traj_inds:\n",
    "    well = t[:2]\n",
    "    traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    \n",
    "    valid_fs = []\n",
    "    ds = []\n",
    "    d_angs = []\n",
    "    for i, f in enumerate(traj_fs):\n",
    "        t_point = t_keys[i]\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            d_ang = traj_positions[t][t_point+t_lag] - traj_positions[t][t_point]\n",
    "            d_ang = cmath.polar(complex(d_ang[1], d_ang[0]))[1]\n",
    "            valid_fs.append(f)\n",
    "            ds.append(d)\n",
    "            d_angs.append(d_ang)\n",
    "\n",
    "    traj_cell_aps = [cell_aps[f][0] for f in valid_fs]\n",
    "    traj_cell_angs = [cell_aps[f][1] for f in valid_fs]\n",
    "\n",
    "    angs1 = [a for i, a in enumerate(d_angs) if traj_cell_aps[i] > 1.1] # Orientation of movement, 0 ~ 2pi\n",
    "    angs2 = [a for i, a in enumerate(traj_cell_angs) if traj_cell_aps[i] > 1.1]\n",
    "    angs2 = [a if a > 0 else a + np.pi for a in angs2] # Orientation of cell long axis, 0~pi\n",
    "    angs1_all.extend(angs1)\n",
    "    angs2_all.extend(angs2)\n",
    "    ds = [d for i, d in enumerate(ds) if traj_cell_aps[i] > 1.1]\n",
    "    valid_fs_ = [f for i, f in enumerate(valid_fs) if traj_cell_aps[i] > 1.1]\n",
    "    if len(angs1) <= 2:\n",
    "        continue\n",
    "    \n",
    "    ang_diffs = [(a1 - a2)%(np.pi) for a1, a2 in zip(angs1, angs2)]\n",
    "    #ang_diffs = [a if a < np.pi/2 else a - np.pi for a in ang_diffs]\n",
    "    ang_diffs_all.extend(ang_diffs)\n",
    "    for f, a in zip(valid_fs_, ang_diffs):\n",
    "        patch_orientations[f] = a\n",
    "    for f, d in zip(valid_fs_, ds):\n",
    "        patch_displacements[f] = d\n",
    "    \n",
    "    # Pool angles along the traj\n",
    "    merged_x = sum([d * np.cos(2 * ang) for d, ang in zip(ds, ang_diffs)])\n",
    "    merged_y = sum([d * np.sin(2 * ang) for d, ang in zip(ds, ang_diffs)])\n",
    "    merged_d, merged_ang_diff = cmath.polar(complex(merged_x, merged_y))\n",
    "    \n",
    "    assert np.allclose(merged_d, np.sqrt(merged_x**2 + merged_y**2))\n",
    "    traj_orientations[t] = merged_ang_diff / 2\n",
    "    traj_orientations2[t] = np.arctan(merged_y/merged_x) / 2\n",
    "    traj_orientation_stds[t] = merged_d/sum(ds)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Calculate Cell Sizes ###\n",
    "cell_sizes = {}\n",
    "for w in wells:\n",
    "    w_fs = fs[w]\n",
    "    \n",
    "    paths = set(os.path.split(f)[0] for f in w_fs)\n",
    "    paths = [os.path.join(path, 'cell_pixel_assignments.pkl') for path in paths]\n",
    "    pixel_assigns = {path: pickle.load(open(path, 'rb')) for path in paths}\n",
    "\n",
    "    for f in w_fs:\n",
    "        path, cell_file = os.path.split(f)\n",
    "        path = os.path.join(path, 'cell_pixel_assignments.pkl')\n",
    "        t_point, cell_id = os.path.splitext(cell_file)[0].split('_')\n",
    "        pixel_assign = pixel_assigns[path]\n",
    "        \n",
    "        cell_pixel_ps, cell_pixel_as = pixel_assign[int(t_point)]\n",
    "        size = np.where(cell_pixel_as == int(cell_id))[0].shape[0]\n",
    "        cell_sizes[f] = size\n",
    "with open(os.path.join(raw_folder, 'all_patches_cell_sizes.pkl'), 'wb') as f:\n",
    "    pickle.dump(cell_sizes, f)\n",
    "\n",
    "### Calculate Cell Peak Intensities. Aspect Ratios ###\n",
    "cell_intensities = {}\n",
    "cell_aprs = {}\n",
    "cell_aprs_nr = {}\n",
    "for site in sites_NOVEMBER:\n",
    "    print(site)\n",
    "    well = site[:2]\n",
    "    paths = [os.path.join(supp_folder, '%s-supps' % well, '%s' % site, 'stacks_%d.pkl' % i) for i in range(159)]\n",
    "    for path in paths:\n",
    "        p_dat = pickle.load(open(path, 'rb'))\n",
    "        for k, v in p_dat.items():\n",
    "            mat = v['masked_mat']\n",
    "            cell_intensities[k] = get_density(mat)\n",
    "            cell_aprs[k] = get_angle_apr(mat)\n",
    "            cell_aprs_nr[k] = get_aspect_ratio_no_rotation(mat)\n",
    "    with open(os.path.join(raw_folder, 'all_patches_cell_intensities.pkl'), 'wb') as f:\n",
    "        pickle.dump(cell_intensities, f)\n",
    "    with open(os.path.join(raw_folder, 'all_patches_cell_aspect_ratios.pkl'), 'wb') as f:\n",
    "        pickle.dump(cell_aprs, f)\n",
    "    with open(os.path.join(raw_folder, 'all_patches_cell_aspect_ratios_nr.pkl'), 'wb') as f:\n",
    "        pickle.dump(cell_aprs_nr, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Calculate Cell Envs ###\n",
    "cell_envs = {}\n",
    "for w in wells:\n",
    "    w_fs = fs[w]    \n",
    "    \n",
    "    paths = set(os.path.split(f)[0] for f in w_fs)\n",
    "    paths = [os.path.join(path, 'cell_positions.pkl') for path in paths]\n",
    "    cell_nbs = {}\n",
    "    for path in paths:\n",
    "        cell_positions = pickle.load(open(path, 'rb'))\n",
    "        cell_nb = {}\n",
    "        for t_point in cell_positions:\n",
    "            poses = dict(sum(cell_positions[t_point], []))\n",
    "            inds = sorted(poses.keys())\n",
    "            positions = np.array([poses[i] for i in inds])\n",
    "            dist_mat = np.linalg.norm(positions.reshape((-1, 1, 2)) - positions.reshape((1, -1, 2)), ord=2, axis=2)\n",
    "            cell_nb[t_point] = (inds, dist_mat)\n",
    "        cell_nbs[path] = cell_nb\n",
    "\n",
    "    for f in w_fs:\n",
    "        path, cell_file = os.path.split(f)\n",
    "        path = os.path.join(path, 'cell_positions.pkl')\n",
    "        t_point, cell_id = os.path.splitext(cell_file)[0].split('_')\n",
    "        inds, dist_mat = cell_nbs[path][int(t_point)]\n",
    "        neighbors = dist_mat[inds.index(int(cell_id))]\n",
    "        cell_envs[f] = neighbors\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Samples along each PC axis ###\n",
    "slices = []\n",
    "for pc_i in range(4):\n",
    "    PCs = all_dats[:, pc_i]\n",
    "    for i in range(5):\n",
    "        low_thr = np.percentile(PCs, i * 20)\n",
    "        up_thr = np.percentile(PCs, (i+1)* 20)\n",
    "        inds = np.where((PCs > low_thr) & (PCs < up_thr))[0]\n",
    "        inds = np.random.choice(inds, (1000,), replace=False)\n",
    "        fs_selected = [all_fs[i] for i in inds]\n",
    "        samples = [all_patches[f].data.numpy()[0, 0] for f in fs_selected]\n",
    "        avg_slice = np.stack(samples, 0).mean(0)\n",
    "        plt.subplot(5, 5, i+1)\n",
    "        plt.imshow(avg_slice, vmin=0.49, vmax=0.75)\n",
    "        plt.axis('off')\n",
    "    plt.savefig('NOVEMBER_PC%d_trend.png' % (pc_i+1), dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Sample input/output ###\n",
    "model = VQ_VAE(alpha=0.0005, gpu=True)\n",
    "model = model.cuda()\n",
    "model.load_state_dict(torch.load('HiddenStateExtractor/save_0005_bkp4.pt'))\n",
    "\n",
    "sample_fs = ['/gpfs/CompMicro/Projects/learningCellState/microglia/raw_for_segmentation/NOVEMBER/supp/B4-supps/B4-Site_2/9_50.h5',\n",
    "             '/gpfs/CompMicro/Projects/learningCellState/microglia/raw_for_segmentation/NOVEMBER/supp/C5-supps/C5-Site_2/23_79.h5',\n",
    "             '/gpfs/CompMicro/Projects/learningCellState/microglia/raw_for_segmentation/NOVEMBER/supp/C5-supps/C5-Site_3/10_34.h5']\n",
    "for i, f in enumerate(sample_fs):\n",
    "    sample = all_patches[f]\n",
    "    output = model(sample.cuda())[0]\n",
    "    inp = sample.cpu().data.numpy()\n",
    "    out = output.cpu().data.numpy()\n",
    "    input_phase = (inp[0, 0] * 65535).astype('uint16')\n",
    "    output_phase = (out[0, 0] * 65535).astype('uint16')\n",
    "    input_retardance = (inp[0, 1] * 65535).astype('uint16')\n",
    "    output_retardance = (out[0, 1] * 65535).astype('uint16')\n",
    "    cv2.imwrite('NOVEMBER_samples_%d_input_phase.png' % i, enhance_contrast(input_phase, 1., -10000)) # Note dataset has been rescaled\n",
    "    cv2.imwrite('NOVEMBER_samples_%d_output_phase.png' % i, enhance_contrast(output_phase, 1., -10000))\n",
    "    cv2.imwrite('NOVEMBER_samples_%d_input_retardance.png' % i, enhance_contrast(input_retardance, 2., 0.))\n",
    "    cv2.imwrite('NOVEMBER_samples_%d_output_retardance.png' % i, enhance_contrast(output_retardance, 2., 0.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### PCA plot for fig 3 ###\n",
    "sizes = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_sizes.pkl'), 'rb'))\n",
    "\n",
    "df = {'PC1': np.concatenate([patch_PC1[w] for w in wells_]),\n",
    "      'PC2': np.concatenate([patch_PC2[w] for w in wells_]),\n",
    "      'sizes': np.concatenate([[sizes[f] for f in fs[w]] for w in wells_])}\n",
    "\n",
    "cmap = matplotlib.cm.get_cmap('BuPu')  \n",
    "range_min = np.log(min(df['sizes']))\n",
    "range_max = np.log(max(df['sizes']))\n",
    "cs = [cmap(((np.log(s) - range_min)/(range_max - range_min))**1.5) for s in df['sizes']]\n",
    "\n",
    "plt.clf()\n",
    "sns.set_style('white')\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "random_subset_inds = np.random.choice(np.arange(len(df['PC1'])), (80000,), replace=False)\n",
    "\n",
    "ax.scatter(df['PC1'][random_subset_inds], \n",
    "           df['PC2'][random_subset_inds], \n",
    "           c=[cs[i] for i in random_subset_inds], \n",
    "           s=1., \n",
    "           edgecolors='none')\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "\n",
    "\n",
    "traj_samples = ['B2-Site_0/35',\n",
    "                'C4-Site_2/189',\n",
    "                'B2-Site_5/21',\n",
    "                'C4-Site_2/3']\n",
    "selected_frames = [np.array([0, 60, 90, 120, 150]),\n",
    "                   np.array([0, 30, 45, 60, 74]),\n",
    "                   np.array([0, 60, 90, 120, 150]),\n",
    "                   np.array([0, 60, 80, 120, 140])]\n",
    "cmap2 = matplotlib.cm.get_cmap('tab10')\n",
    "colors2 = [cmap2.colors[1],\n",
    "           cmap2.colors[5], \n",
    "           (0.15, 0.5, 0.15), \n",
    "           (0.2, 0.2, 0.2)]\n",
    "for ct, (t, inds, c) in enumerate(zip(traj_samples, selected_frames, colors2)):\n",
    "    well = t[:2]\n",
    "    order = np.array(traj_inds[t])\n",
    "    ax.plot(dats[well][order][:, 0], dats[well][order][:, 1], '.--', c=c, linewidth=0.5, markersize=0.5)\n",
    "    ax.plot(dats[well][order][inds][:, 0], dats[well][order][inds][:, 1], '.', c=c, markersize=2.0)\n",
    "    for i in range(len(inds) - 1):\n",
    "        ind0 = inds[i]\n",
    "        ind1 = inds[i+1]\n",
    "        ax.arrow(dats[well][order[ind0], 0],\n",
    "                 dats[well][order[ind0], 1],\n",
    "                 dats[well][order[ind1], 0] - dats[well][order[ind0], 0],\n",
    "                 dats[well][order[ind1], 1] - dats[well][order[ind0], 1],\n",
    "                 fc='none',\n",
    "                 ec=c,\n",
    "                 length_includes_head=True,\n",
    "                 head_width=0.2, \n",
    "                 head_length=0.3)\n",
    "    names = []\n",
    "    output_paths = []\n",
    "    for j, ind in enumerate(order[inds]):\n",
    "        f = fs[well][ind]\n",
    "        site = f.split('/')[-2]\n",
    "        well = site[:2]\n",
    "        t_point = int(f.split('/')[-1].split('_')[0])\n",
    "        \n",
    "        path = os.path.join(supp_folder, '%s-supps' % well, site, 'stacks_%d.pkl' % t_point)\n",
    "        sample_dat = pickle.load(open(path, 'rb'))[f]['mat']\n",
    "        cv2.imwrite('NOVEMBER_traj_sample_%d_%d.png' % (ct, j), \n",
    "                    enhance_contrast(sample_dat[:, :, 0], phase_a, phase_b).astype('uint16'))\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"NOVEMBER_PCA.eps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ts_of_I = []\n",
    "# for t in trajs:\n",
    "#     well = t[:2]\n",
    "#     t_pc = np.array([dats[well][ind, :2] for ind in traj_inds[t]])\n",
    "#     t_neighbors = [sorted(cell_envs[fs[well][ind]])[1] for ind in traj_inds[t]]\n",
    "#     if np.percentile(t_neighbors, 5) < 70:\n",
    "#         continue\n",
    "#     if len(t_pc) > 30:\n",
    "#         i = 0\n",
    "#         centers = {}\n",
    "#         while (i+10) < len(t_pc):\n",
    "#             center = t_pc[i:(i+10)].mean(0)\n",
    "#             std = t_pc[i:(i+10)].std(0)\n",
    "#             if std.sum() < 2:\n",
    "#                 centers[i] = center\n",
    "#                 i += 12\n",
    "#             else:\n",
    "#                 i += 1\n",
    "#         if len(centers) > 1:\n",
    "#             centers = np.array(list(centers.values()))\n",
    "#             if np.max(np.linalg.norm(centers.reshape((-1, 1, 2)) - centers.reshape((1, -1, 2)), ord=2, axis=2)) > 4:\n",
    "#                 ts_of_I.append(t)\n",
    "\n",
    "ts_of_I = [\n",
    "    'B2-Site_0/11',\n",
    "    'B2-Site_0/35',\n",
    "    'B2-Site_0/40',\n",
    "    'B2-Site_0/45',\n",
    "    'B2-Site_0/48',\n",
    "    'B2-Site_0/221',\n",
    "    'B2-Site_1/74',\n",
    "    'B2-Site_2/9',\n",
    "    'B2-Site_5/35',\n",
    "    'B2-Site_5/125',\n",
    "    'B4-Site_0/67',\n",
    "    'B4-Site_6/65',\n",
    "    'B5-Site_7/3',\n",
    "    'C4-Site_0/49',\n",
    "    'C4-Site_0/77',\n",
    "    'C4-Site_2/51',\n",
    "    'C4-Site_2/52',\n",
    "    'C4-Site_2/53',\n",
    "    'C4-Site_2/59',\n",
    "    'C4-Site_2/149',\n",
    "    'C4-Site_2/189',\n",
    "    'C4-Site_3/109',\n",
    "    'C5-Site_3/22'\n",
    "]\n",
    "\n",
    "# for t in ts_of_I:\n",
    "#     plt.clf()\n",
    "#     well = t[:2]\n",
    "#     t_pc = np.array([dats[well][ind, :2] for ind in traj_inds[t]])\n",
    "#     plt.plot(t_pc[:, 0], t_pc[:, 1], '.-')\n",
    "#     plt.xlim(-7, 11)\n",
    "#     plt.ylim(-4, 12)\n",
    "#     plt.savefig('traj_selected/%s.png' % t.replace('/', '_'))\n",
    "#    save_traj_bbox(t, 'traj_selected/%s_box.gif' % t.replace('/', '_'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### PC1, PC2, speed individual distribution ###\n",
    "# Patch level\n",
    "# sns.set_style(\"whitegrid\")\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(4.5, 3))\n",
    "# for well in wells_:\n",
    "#     freqs, bins = np.histogram(patch_PC1[well], bins=bins_PC1, normed=True)\n",
    "#     x = (bins[:-1] + bins[1:])/2\n",
    "#     plt.plot(x, freqs, c=colors[well], label=legends[well])\n",
    "# plt.xlabel(\"\")\n",
    "# plt.ylabel(\"\")\n",
    "# plt.legend()\n",
    "# plt.grid(b=False, which='major', axis='x')\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(\"NOVEMBER_all_patch_PC1.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_all_patch_PC1.eps\")\n",
    "\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(4.5, 3))\n",
    "# for well in wells_:\n",
    "#     freqs, bins = np.histogram(patch_PC2[well], bins=bins_PC2, normed=True)\n",
    "#     x = (bins[:-1] + bins[1:])/2\n",
    "#     plt.plot(x, freqs, c=colors[well], label=legends[well])\n",
    "# plt.xlabel(\"\")\n",
    "# plt.ylabel(\"\")\n",
    "# plt.legend()\n",
    "# plt.grid(b=False, which='major', axis='x')\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(\"NOVEMBER_all_patch_PC2.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_all_patch_PC2.eps\")\n",
    "\n",
    "# Trajectory level\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(4.5, 3))\n",
    "for well in wells_:\n",
    "    freqs, bins = np.histogram(traj_PC1[well], bins=bins_PC1, normed=True)\n",
    "    x = (bins[:-1] + bins[1:])/2\n",
    "    plt.plot(x, freqs, c=colors[well], label=legends[well])\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.legend()\n",
    "plt.grid(b=False, which='major', axis='x')\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"NOVEMBER_all_traj_PC1.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_all_traj_PC1.eps\")\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(4.5, 3))\n",
    "for well in wells_:\n",
    "    freqs, bins = np.histogram(traj_PC2[well], bins=bins_PC2, normed=True)\n",
    "    x = (bins[:-1] + bins[1:])/2\n",
    "    plt.plot(x, freqs, c=colors[well], label=legends[well])\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.legend()\n",
    "plt.grid(b=False, which='major', axis='x')\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"NOVEMBER_all_traj_PC2.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_all_traj_PC2.eps\")\n",
    "\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(4.5, 3))\n",
    "# for well in wells_:\n",
    "#     freqs, bins = np.histogram(traj_speed[well], bins=bins_speed, normed=True)\n",
    "#     x = (bins[:-1] + bins[1:])/2\n",
    "#     plt.plot(x, freqs, c=colors[well], label=legends[well])\n",
    "# plt.xlabel(\"\")\n",
    "# plt.ylabel(\"\")\n",
    "# plt.legend()\n",
    "# plt.grid(b=False, which='major', axis='x')\n",
    "# speed_ticks = [4., 8., 16., 32., 64., 128.]\n",
    "# plt.gca().set_xticks(np.log(speed_ticks))\n",
    "# plt.gca().set_xticklabels(speed_ticks)\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(\"NOVEMBER_all_traj_speed.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_all_traj_speed.eps\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### PC1-PC2, PC1-speed, PC2-speed density plot ###\n",
    "\n",
    "# plot_fn = plot_joint_density\n",
    "plot_fn = plot_joint_kde\n",
    "sns.set_style(\"white\")\n",
    "\n",
    "# Patch level\n",
    "# for well in wells:\n",
    "#     df = {'PC1': patch_PC1[well], 'PC2': patch_PC2[well]}\n",
    "#     plt.clf()\n",
    "#     plot_fn('PC1', 'PC2', df, bins_PC1, bins_PC2, cmap=cmaps[well])\n",
    "#     plt.xlabel(\"\")\n",
    "#     plt.ylabel(\"\")\n",
    "#     plt.text(bins_PC1[2], bins_PC2[-3], legends[well], fontdict={\"size\": 16})\n",
    "#     plt.tight_layout()\n",
    "#     plt.savefig(\"NOVEMBER_%s_patch_PC1_PC2.png\" % well, dpi=300)\n",
    "#     plt.savefig(\"NOVEMBER_%s_patch_PC1_PC2.eps\" % well)\n",
    "\n",
    "# df = {'PC1': np.concatenate([patch_PC1[w] for w in wells]),\n",
    "#       'PC2': np.concatenate([patch_PC2[w] for w in wells])}\n",
    "# plt.clf()\n",
    "# plot_fn('PC1', 'PC2', df, bins_PC1, bins_PC2, cmap=cmaps['all'])\n",
    "# plt.xlabel(\"\")\n",
    "# plt.ylabel(\"\")\n",
    "# plt.text(bins_PC1[2], bins_PC2[-3], 'All', fontdict={\"size\": 16})\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(\"NOVEMBER_all_patch_PC1_PC2.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_all_patch_PC1_PC2.eps\")\n",
    "\n",
    "\n",
    "# Trajectory level\n",
    "for well in wells_:\n",
    "    df = {'PC1': traj_PC1[well], 'PC2': traj_PC2[well], 'Speed': traj_speed[well]}\n",
    "    speed_ticks = [4, 16, 64]\n",
    "    \n",
    "    plt.clf()\n",
    "    f = plt.figure(figsize=(2.5, 2.5))\n",
    "    sns.kdeplot(df['PC1'], df['Speed'], cmap=cmaps[well], shade=True)\n",
    "    plt.xlabel(\"\")\n",
    "    plt.ylabel(\"\")\n",
    "    plt.xlim(bins_PC1[0], bins_PC1[-1])\n",
    "    plt.ylim(bins_speed[0], bins_speed[-1])\n",
    "    plt.gca().set_yticks(np.log(speed_ticks))\n",
    "    plt.gca().set_yticklabels(speed_ticks)\n",
    "    plt.text(bins_PC1[1], bins_speed[1], legends[well], fontdict={\"size\": 16})\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"NOVEMBER_%s_trajectory_PC1_speed.png\" % well, dpi=300)\n",
    "    plt.savefig(\"NOVEMBER_%s_trajectory_PC1_speed.eps\" % well)\n",
    "\n",
    "    plt.clf()\n",
    "    f = plt.figure(figsize=(2.5, 2.5))\n",
    "    sns.kdeplot(df['PC2'], df['Speed'], cmap=cmaps[well], shade=True)\n",
    "    plt.xlabel(\"\")\n",
    "    plt.ylabel(\"\")\n",
    "    plt.xlim(bins_PC2[0], bins_PC2[-1])\n",
    "    plt.ylim(bins_speed[0], bins_speed[-1])\n",
    "    plt.gca().set_yticks(np.log(speed_ticks))\n",
    "    plt.gca().set_yticklabels(speed_ticks)\n",
    "    plt.text(bins_PC2[1], bins_speed[1], legends[well], fontdict={\"size\": 16})\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"NOVEMBER_%s_trajectory_PC2_speed.png\" % well, dpi=300)\n",
    "    plt.savefig(\"NOVEMBER_%s_trajectory_PC2_speed.eps\" % well)\n",
    "\n",
    "speed_ticks = [4, 8, 16, 32, 64, 128]\n",
    "df = {'PC1': np.concatenate([traj_PC1[w] for w in wells_]),\n",
    "      'PC2': np.concatenate([traj_PC2[w] for w in wells_]),\n",
    "      'Speed': np.concatenate([traj_speed[w] for w in wells_])}\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3, 3))\n",
    "sns.kdeplot(df['PC1'], df['Speed'], cmap=ListedColormap(generate_color_vectors('#ffffff', '#888888')), shade=True)\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.xlim(bins_PC1[0], bins_PC1[-1])\n",
    "plt.ylim(bins_speed[0], bins_speed[-1])\n",
    "plt.gca().set_yticks(np.log(speed_ticks))\n",
    "plt.gca().set_yticklabels(speed_ticks)\n",
    "plt.text(bins_PC1[1], bins_speed[1], 'All', fontdict={\"size\": 20})\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"NOVEMBER_all_trajectory_PC1_speed.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_all_trajectory_PC1_speed.eps\")\n",
    "    \n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3, 3))\n",
    "sns.kdeplot(df['PC2'], df['Speed'], cmap=ListedColormap(generate_color_vectors('#ffffff', '#888888')), shade=True)\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.xlim(bins_PC2[0], bins_PC2[-1])\n",
    "plt.ylim(bins_speed[0], bins_speed[-1])\n",
    "plt.gca().set_yticks(np.log(speed_ticks))\n",
    "plt.gca().set_yticklabels(speed_ticks)\n",
    "plt.text(bins_PC2[1], bins_speed[1], 'All', fontdict={\"size\": 20})\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"NOVEMBER_all_trajectory_PC2_speed.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_all_trajectory_PC2_speed.eps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Representative Trajectories ###\n",
    "t_lag = 1\n",
    "def extract_representatives(traj_pool, target_PC1=(None, None), target_PC2=(None, None), target_dist=(None, None)):\n",
    "    selected_ts = []\n",
    "    properties = {}\n",
    "    for t in traj_pool:\n",
    "        well = t[:2]\n",
    "        t_keys = sorted(trajs[t].keys())\n",
    "        dists = []\n",
    "        for t_point in t_keys:\n",
    "            if (t_point + t_lag) in t_keys:\n",
    "                d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                                   traj_positions[t][t_point], ord=2)\n",
    "                dists.append(d)\n",
    "        traj_pc1 = [dats[well][ind, 0] for ind in traj_inds[t]]\n",
    "        traj_pc2 = [dats[well][ind, 1] for ind in traj_inds[t]]\n",
    "        traj_dist = np.array(dists) * 0.72222\n",
    "        if not target_PC1[0] is None:\n",
    "            if np.mean(traj_pc1) < target_PC1[0]:\n",
    "                continue\n",
    "        if not target_PC1[1] is None:\n",
    "            if np.mean(traj_pc1) > target_PC1[1]:\n",
    "                continue\n",
    "        if not target_PC2[0] is None:\n",
    "            if np.mean(traj_pc2) < target_PC2[0]:\n",
    "                continue\n",
    "        if not target_PC2[1] is None:\n",
    "            if np.mean(traj_pc2) > target_PC2[1]:\n",
    "                continue\n",
    "        if not target_dist[0] is None:\n",
    "            if np.mean(traj_dist) < target_dist[0]:\n",
    "                continue\n",
    "        if not target_dist[1] is None:\n",
    "            if np.mean(traj_dist) > target_dist[1]:\n",
    "                continue\n",
    "        selected_ts.append(t)\n",
    "        properties[t] = (traj_pc1, traj_pc2, traj_dist)\n",
    "    selected_ts = sorted(selected_ts, key=lambda x: np.std(properties[x][0]) + np.std(properties[x][1]))\n",
    "    return selected_ts\n",
    "\n",
    "# model = VQ_VAE(alpha=0.0005, gpu=True)\n",
    "# model = model.cuda()\n",
    "# model.load_state_dict(torch.load('HiddenStateExtractor/save_0005_bkp4.pt'))\n",
    "sample_fs = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing B4-Site_2_282\n",
      "Writing B4-Site_0_89\n",
      "Writing B4-Site_0_1\n",
      "Writing B4-Site_2_51\n",
      "Writing B4-Site_6_427\n",
      "Writing B4-Site_3_30\n"
     ]
    }
   ],
   "source": [
    "# Extract representative trajectories: B4\n",
    "well = 'B4'\n",
    "target_PC2 = [-1, 0]\n",
    "target_dist = [8., 18.]\n",
    "traj_pool = [t for t in trajs if t.startswith(well)]\n",
    "selected_ts = extract_representatives(traj_pool, target_PC2=target_PC2, target_dist=target_dist)\n",
    "selected_fs_pool = []\n",
    "for t in selected_ts[:20]:\n",
    "    selected_fs_pool.extend([fs[well][ind] for ind in traj_inds[t]])\n",
    "\n",
    "plot_ts = [t for t in selected_ts[:30] if len(traj_inds[t]) > 30]\n",
    "for t in np.random.choice(plot_ts, (6,), replace=False):\n",
    "    print(\"Writing %s\" % t.replace('/', '_'))\n",
    "    save_traj_bbox(t, 'supp_video_%s_sample_bbox_%s.gif' % (well, t.replace('/', '_')))\n",
    "    save_movie(t, 'supp_video_%s_sample_movie_%s.gif' % (well, t.replace('/', '_')))\n",
    "\n",
    "np.random.seed(123)\n",
    "sample_fs[well] = np.random.choice(selected_fs_pool, (4,), replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing B5-Site_2_100\n",
      "Writing B5-Site_7_28\n",
      "Writing B5-Site_1_7\n",
      "Writing B5-Site_2_243\n",
      "Writing B5-Site_1_252\n",
      "Writing B5-Site_6_72\n"
     ]
    }
   ],
   "source": [
    "# Extract representative trajectories: B5\n",
    "well = 'B5'\n",
    "target_PC2 = [-1.5, -0.5]\n",
    "target_dist = [4., 12.]\n",
    "traj_pool = [t for t in trajs if t.startswith(well)]\n",
    "selected_ts = extract_representatives(traj_pool, target_PC2=target_PC2, target_dist=target_dist)\n",
    "selected_fs_pool = []\n",
    "for t in selected_ts[:20]:\n",
    "    selected_fs_pool.extend([fs[well][ind] for ind in traj_inds[t]])\n",
    "\n",
    "plot_ts = [t for t in selected_ts[:30] if len(traj_inds[t]) > 30]\n",
    "for t in np.random.choice(plot_ts, (6,), replace=False):\n",
    "    print(\"Writing %s\" % t.replace('/', '_'))\n",
    "    save_traj_bbox(t, 'supp_video_%s_sample_bbox_%s.gif' % (well, t.replace('/', '_')))\n",
    "    save_movie(t, 'supp_video_%s_sample_movie_%s.gif' % (well, t.replace('/', '_')))\n",
    "    \n",
    "np.random.seed(123)\n",
    "sample_fs[well] = np.random.choice(selected_fs_pool, (4,), replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract representative trajectories: C4\n",
    "well = 'C4'\n",
    "target_PC2 = [0, 1]\n",
    "target_dist = [8., 18.]\n",
    "traj_pool = [t for t in trajs if t.startswith(well)]\n",
    "selected_ts = extract_representatives(traj_pool, target_PC2=target_PC2, target_dist=target_dist)\n",
    "selected_fs_pool = []\n",
    "for t in selected_ts[:20]:\n",
    "    selected_fs_pool.extend([fs[well][ind] for ind in traj_inds[t]])\n",
    "\n",
    "plot_ts = [t for t in selected_ts[:30] if len(traj_inds[t]) > 30]\n",
    "for t in np.random.choice(plot_ts, (6,), replace=False):\n",
    "    print(\"Writing %s\" % t.replace('/', '_'))\n",
    "    save_traj_bbox(t, 'supp_video_%s_sample_bbox_%s.gif' % (well, t.replace('/', '_')))\n",
    "    save_movie(t, 'supp_video_%s_sample_movie_%s.gif' % (well, t.replace('/', '_')))\n",
    "\n",
    "np.random.seed(123)\n",
    "sample_fs[well] = np.random.choice(selected_fs_pool, (4,), replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing C5-Site_5_375\n",
      "Writing C5-Site_3_349\n",
      "Writing C5-Site_3_9\n",
      "Writing C5-Site_1_441\n",
      "Writing C5-Site_3_59\n"
     ]
    }
   ],
   "source": [
    "# Extract representative trajectories: C5\n",
    "well = 'C5'\n",
    "target_PC2 = [2.5, 3.5]\n",
    "target_dist = [18., 36.]\n",
    "traj_pool = [t for t in trajs if t.startswith(well)]\n",
    "selected_ts = extract_representatives(traj_pool, target_PC2=target_PC2, target_dist=target_dist)\n",
    "selected_fs_pool = []\n",
    "for t in selected_ts[:20]:\n",
    "    selected_fs_pool.extend([fs[well][ind] for ind in traj_inds[t]])\n",
    "\n",
    "plot_ts = [t for t in selected_ts[:30] if len(traj_inds[t]) > 20]\n",
    "for t in np.random.choice(plot_ts, (6,), replace=False):\n",
    "    print(\"Writing %s\" % t.replace('/', '_'))\n",
    "    save_traj_bbox(t, 'supp_video_%s_sample_bbox_%s.gif' % (well, t.replace('/', '_')))\n",
    "    save_movie(t, 'supp_video_%s_sample_movie_%s.gif' % (well, t.replace('/', '_')))\n",
    "\n",
    "np.random.seed(123)\n",
    "sample_fs[well] = np.random.choice(selected_fs_pool, (4,), replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing B2-Site_2_39\n",
      "Writing B2-Site_5_81\n",
      "Writing B2-Site_2_243\n",
      "Writing B2-Site_0_43\n",
      "Writing B2-Site_1_84\n",
      "Writing B2-Site_2_24\n",
      "Writing B2-Site_5_59\n",
      "Writing B2-Site_0_214\n"
     ]
    }
   ],
   "source": [
    "# Extract representative trajectories: B2\n",
    "well = 'B2'\n",
    "target_PC2 = [3.5, 4.5]\n",
    "target_dist = [12., 24.]\n",
    "traj_pool = [t for t in trajs if t.startswith(well)]\n",
    "selected_ts = extract_representatives(traj_pool, target_PC2=target_PC2, target_dist=target_dist)\n",
    "selected_fs_pool = []\n",
    "for t in selected_ts[:20]:\n",
    "    selected_fs_pool.extend([fs[well][ind] for ind in traj_inds[t]])\n",
    "plot_ts = [t for t in selected_ts[:30] if len(traj_inds[t]) > 30]\n",
    "    \n",
    "target_PC2 = [0, 2]\n",
    "target_dist = [4., 12.]\n",
    "traj_pool = [t for t in trajs if t.startswith(well)]\n",
    "selected_ts = extract_representatives(traj_pool, target_PC2=target_PC2, target_dist=target_dist)\n",
    "for t in selected_ts[:20]:\n",
    "    selected_fs_pool.extend([fs[well][ind] for ind in traj_inds[t]])\n",
    "plot_ts.extend([t for t in selected_ts[:30] if len(traj_inds[t]) > 30])\n",
    "for t in np.random.choice(plot_ts, (8,), replace=False):\n",
    "    print(\"Writing %s\" % t.replace('/', '_'))\n",
    "    save_traj_bbox(t, 'supp_video_%s_sample_bbox_%s.gif' % (well, t.replace('/', '_')))\n",
    "    save_movie(t, 'supp_video_%s_sample_movie_%s.gif' % (well, t.replace('/', '_')))\n",
    "\n",
    "np.random.seed(123)\n",
    "sample_fs[well] = np.random.choice(selected_fs_pool, (4,), replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for well in sample_fs:\n",
    "    for i, f in enumerate(sample_fs[well]):\n",
    "        sample = all_patches[f]\n",
    "        output = model(sample.cuda())[0]\n",
    "        inp = sample.cpu().data.numpy()\n",
    "        out = output.cpu().data.numpy()\n",
    "        input_phase = (inp[0, 0] * 65535).astype('uint16')\n",
    "        output_phase = (out[0, 0] * 65535).astype('uint16')\n",
    "        cv2.imwrite('NOVEMBER_samples_%s_%d_input_phase.png' % (well, i), enhance_contrast(input_phase, 1., -10000)) # Note dataset has been rescaled\n",
    "        cv2.imwrite('NOVEMBER_samples_%s_%d_output_phase.png' % (well, i), enhance_contrast(output_phase, 1., -10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "### GMM to multiple states ###\n",
    "t_lag = 1\n",
    "traj_properties = {}\n",
    "X = []\n",
    "Y = []\n",
    "t_arrays = []\n",
    "for t in trajs:\n",
    "    well = t[:2]\n",
    "    if not well in wells_:\n",
    "        continue\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    dists = []\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            dists.append(d)\n",
    "        \n",
    "    traj_PC = [dats[well][ind] for ind in traj_inds[t]]\n",
    "    traj_dist = dists\n",
    "    traj_properties[t] = (traj_PC, traj_dist)\n",
    "    X.append(np.concatenate([np.array(np.log(np.mean(traj_dist) * 0.325 / 0.1518)).reshape((-1,)), np.mean(traj_PC, 0)]))\n",
    "    Y.append(sorted(wells_).index(well))\n",
    "    t_arrays.append(t)\n",
    "    \n",
    "X = np.array(X)\n",
    "Y = np.array(Y)\n",
    "std_unit = np.std(X, 0)\n",
    "std_unit = np.clip(std_unit, 0.6, 10.)\n",
    "# std_unit[1:] = np.clip(std_unit[1:], std_unit[1], 10.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.37813055 0.62186945]\n",
      " [0.90453519 0.09546481]\n",
      " [0.98587095 0.01412905]\n",
      " [0.13003713 0.86996287]]\n"
     ]
    }
   ],
   "source": [
    "### GMM ###\n",
    "def calculate_sample_prob_mat(X, centers, stds):\n",
    "    # Sample prob mat should be N * 2\n",
    "    n_feat = X.shape[1]\n",
    "    X_ = X.reshape((-1, 1, n_feat))\n",
    "    centers_ = np.array(centers).reshape((1, -1, n_feat))\n",
    "    stds_ = np.array(stds).reshape((1, -1, n_feat))\n",
    "    prob_mat = np.square((X_ - centers_)/stds_).sum(2)\n",
    "    prob_mat = prob_mat - prob_mat.min(1, keepdims=True)\n",
    "    prob_mat = np.exp(-0.5 * prob_mat)\n",
    "    return prob_mat\n",
    "\n",
    "\n",
    "def initialize_well_prob_mat(sample_prob_mat, y):\n",
    "    # Well prob mat should be 5*2\n",
    "    classes = sorted(np.unique(y))\n",
    "    prob_mat = np.zeros((len(classes), sample_prob_mat.shape[1]))\n",
    "    for i, c in enumerate(classes):\n",
    "        line = sample_prob_mat[np.where(y == c)].sum(0)\n",
    "        line = line/line.sum()\n",
    "        prob_mat[i] = line\n",
    "    return prob_mat\n",
    "\n",
    "\n",
    "def get_merged_prob_mat(X, y, centers, stds, well_prob_mat):\n",
    "    # E-step\n",
    "    sample_prob_mat = calculate_sample_prob_mat(X, centers, stds)\n",
    "    prob_mat = []\n",
    "    for i in range(len(X)):\n",
    "        prob_ = sample_prob_mat[i] * well_prob_mat[y[i]]\n",
    "        prob_ = prob_/prob_.sum()\n",
    "        prob_mat.append(prob_)\n",
    "    prob_mat = np.stack(prob_mat, 0)\n",
    "    return prob_mat\n",
    "    \n",
    "\n",
    "def calculate_new_centers(X, y, prob_mat):\n",
    "    # M-step\n",
    "    classes = sorted(np.unique(y))\n",
    "    weights = prob_mat\n",
    "\n",
    "    outlying = np.zeros((X.shape[0],))\n",
    "    for i, c in enumerate(classes):\n",
    "        inds = np.where(y == c)\n",
    "        X_c = X[inds]\n",
    "        median_X_c = np.median(X_c, keepdims=True, axis=0)\n",
    "        outlying[inds] = np.linalg.norm(X_c - median_X_c, axis=1, ord=2)  \n",
    "  \n",
    "    outlying = (1 - 0.7 * (outlying - outlying.min())/(outlying.max() - outlying.min())) ** 10.\n",
    "    weights = weights * outlying.reshape((-1, 1))\n",
    "  \n",
    "    centers = []\n",
    "    stds = []\n",
    "    for i in range(weights.shape[1]):\n",
    "        w = weights[:, i:(i+1)]\n",
    "        center = (w * X).sum(0)/w.sum()\n",
    "        centers.append(center)\n",
    "        std = np.sqrt(((w * (X - center) ** 2).sum(0)/w.sum()))\n",
    "        ratio = np.median((std/std_unit)[:5])\n",
    "        stds.append(ratio * std_unit)\n",
    "\n",
    "    well_prob_mat = []\n",
    "    for i, c in enumerate(classes):\n",
    "        inds = np.where(y == c)\n",
    "        well_prob_mat.append(weights[inds].sum(0)/weights[inds].sum())\n",
    "    well_prob_mat = np.stack(well_prob_mat, 0)\n",
    "    return centers, stds, well_prob_mat\n",
    "  \n",
    "    \n",
    "# Two states or three states\n",
    "init_center1 = np.median(X[np.where(Y == 1)], 0)\n",
    "init_center2 = np.median(X[np.where(Y == 3)], 0)\n",
    "#init_center3 = np.median(X[np.where(Y == 0)], 0)\n",
    "init_center1 += np.random.normal(0, 0.1, init_center1.shape)\n",
    "init_center2 += np.random.normal(0, 0.1, init_center1.shape)\n",
    "#init_center3 += np.random.normal(0, 0.1, init_center1.shape)\n",
    "centers = [init_center1, init_center2]#, init_center3]\n",
    "stds = [0.6*std_unit for c in centers]\n",
    "well_prob_mat = initialize_well_prob_mat(calculate_sample_prob_mat(X, centers, stds), Y)\n",
    "\n",
    "for i in range(20): \n",
    "    prob_mat = get_merged_prob_mat(X, Y, centers, stds, well_prob_mat)\n",
    "    centers, _, well_prob_mat = calculate_new_centers(X, Y, prob_mat)\n",
    "print(well_prob_mat)\n",
    "\n",
    "### Calculate trajectory states ###\n",
    "state_cmaps = [plt.get_cmap(name) for name in ['Blues', 'Reds', 'Greens', 'Oranges']]\n",
    "traj_states = {well: [] for well in wells_}\n",
    "prob_mat = get_merged_prob_mat(X, Y, centers, stds, well_prob_mat)\n",
    "for well in wells_:\n",
    "    names = traj_names[well]\n",
    "    for n in names:\n",
    "        traj_states[well].append(prob_mat[t_arrays.index(n)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [],
   "source": [
    "### UMAP of morphodynamic features ###\n",
    "import umap\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "n = 10\n",
    "d = 0.1\n",
    "X_ = X/std_unit\n",
    "prob_mat = get_merged_prob_mat(X, Y, centers, stds, well_prob_mat)\n",
    "reducer = umap.UMAP(n_neighbors=n, min_dist=d)\n",
    "embedding = reducer.fit_transform(X_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.42592592592592593\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: UserWarning: The following kwargs were not used by contour: 'label'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7940503432494279\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: UserWarning: The following kwargs were not used by contour: 'label'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9428969359331476\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: UserWarning: The following kwargs were not used by contour: 'label'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.24564315352697094\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: UserWarning: The following kwargs were not used by contour: 'label'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 288x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 288x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 288x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import gaussian_kde\n",
    "def density_estimation(m1, m2):\n",
    "    xmin, xmax = m1.min()-0.5, m1.max()+0.5\n",
    "    ymin, ymax = m2.min()-0.5, m2.max()+0.5\n",
    "    xint = (xmax - xmin) / 100\n",
    "    yint = (ymax - ymin) / 100\n",
    "    X, Y = np.mgrid[xmin:xmax:xint, ymin:ymax:yint]\n",
    "    positions = np.stack([X.ravel(), Y.ravel()], 0)\n",
    "    values = np.stack([m1, m2], 0)\n",
    "    kernel = gaussian_kde(values)\n",
    "    Z = np.reshape(kernel(positions), X.shape)\n",
    "    return X, Y, Z\n",
    "\n",
    "m1, m2 = embedding[:, 0], embedding[:, 1]\n",
    "cont_X, cont_Y, cont_Z = density_estimation(m1, m2)\n",
    "xmin, xmax = m1.min()-0.5, m1.max()+0.5\n",
    "ymin, ymax = m2.min()-0.5, m2.max()+0.5\n",
    "\n",
    "cmap = matplotlib.cm.get_cmap('Greys')\n",
    "for i in range(4):\n",
    "    inds = np.where(Y == i)[0]\n",
    "    legend = sorted(wells_)[i]\n",
    "    state1_inds = [i for i in inds if prob_mat[i][0] > 0.5]\n",
    "    state2_inds = [i for i in inds if prob_mat[i][1] > 0.5]\n",
    "    print(len(state1_inds)/(len(state1_inds) + len(state2_inds)))\n",
    "    plt.clf()\n",
    "    f = plt.figure(figsize=(4, 3))\n",
    "    plt.contourf(cont_X, cont_Y, cont_Z>cont_Z.max()*0.15, levels=1, colors=[cmap(0), cmap(0.12)])\n",
    "    plt.plot(embedding[state2_inds][:, 0], \n",
    "             embedding[state2_inds][:, 1], \n",
    "             '.',\n",
    "             c=state_cmaps[1](0.8), \n",
    "             markersize=3.)\n",
    "    plt.plot(embedding[state1_inds][:, 0], \n",
    "             embedding[state1_inds][:, 1], \n",
    "             '.', \n",
    "             c=state_cmaps[0](0.8), \n",
    "             markersize=3.)\n",
    "    plt.xlim(xmin-0.5, xmax+0.5)\n",
    "    plt.xticks([0, 2, 4, 6, 8])\n",
    "    plt.ylim(ymin-0.5, ymax+0.5)\n",
    "    plt.yticks([-2, 0, 2, 4, 6])\n",
    "#     plt.show()\n",
    "    plt.savefig('NOVEMBER_traj_umap_%s.eps' % (sorted(wells_)[i]))\n",
    "    plt.savefig('NOVEMBER_traj_umap_%s.png' % (sorted(wells_)[i]), dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### KDE of the two states in PC1-PC2 ###\n",
    "classes = sorted(np.unique(Y))\n",
    "weights = prob_mat\n",
    "\n",
    "outlying = np.zeros((X.shape[0],))\n",
    "for i, c in enumerate(classes):\n",
    "    inds = np.where(Y == c)\n",
    "    X_c = X[inds]\n",
    "    median_X_c = np.median(X_c, keepdims=True, axis=0)\n",
    "    outlying[inds] = np.linalg.norm(X_c - median_X_c, axis=1, ord=2)  \n",
    "  \n",
    "outlying = (1 - 0.7 * (outlying - outlying.min())/(outlying.max() - outlying.min())) ** 10.\n",
    "weights = weights * outlying.reshape((-1, 1))\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 3))\n",
    "center1_samples = np.where(weights[:, 0] > weights[:, 1])[0]\n",
    "center2_samples = np.where(weights[:, 1] > weights[:, 0])[0]\n",
    "sns.kdeplot(X[center2_samples][:, 1], \n",
    "            X[center2_samples][:, 2],\n",
    "            cmap=state_cmaps[1], \n",
    "            shade_lowest=False,\n",
    "            n_levels=6,\n",
    "            label='State 2')\n",
    "sns.kdeplot(X[center1_samples][:, 1], \n",
    "            X[center1_samples][:, 2],\n",
    "            cmap=state_cmaps[0], \n",
    "            shade_lowest=False,\n",
    "            n_levels=6,\n",
    "            label='State 1')\n",
    "plt.xlim(-5, 7)\n",
    "plt.ylim(-3, 9)\n",
    "plt.legend()\n",
    "# plt.show()\n",
    "plt.savefig('NOVEMBER_state_KDE.png', dpi=300)\n",
    "plt.savefig('NOVEMBER_state_KDE.eps')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 252x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 252x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 252x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Scatter (Arrow) plot of trajectory level PC1 - PC2 - speed ###\n",
    "\n",
    "# traj_vector_K2 = {}\n",
    "# K = 2\n",
    "# for t in trajs:\n",
    "#     well = t[:2]\n",
    "#     if not well in wells_:\n",
    "#         continue\n",
    "#     traj_full_dats = np.stack([dats[well][ind] for ind in traj_inds[t]], 0)\n",
    "#     segs = np.linspace(0, len(traj_inds[t]), K+1).astype(int)\n",
    "#     vs = []\n",
    "#     for i in range(len(segs) - 1):\n",
    "#         v = traj_full_dats[segs[i]:segs[i+1]].mean(0)\n",
    "#         vs.append(v)\n",
    "#     traj_vector_K2[t] = vs\n",
    "\n",
    "# state_lengths = [[], []]\n",
    "speed_ticks = [4., 8., 16., 32., 64., 128.]\n",
    "for i_w, well in enumerate(sorted(wells_)):\n",
    "    print(well)\n",
    "    df = {'PC1': traj_PC1[well],\n",
    "          'PC2': traj_PC2[well],\n",
    "          'Speed': traj_speed[well],\n",
    "          'State': traj_states[well],\n",
    "          'Name': traj_names[well]}\n",
    "\n",
    "    plt.clf()\n",
    "    f = plt.figure(figsize=(3.5, 3))\n",
    "    random_selected_inds = np.random.choice(np.arange(len(df['Name'])), (300,), replace=False)\n",
    "    for i in random_selected_inds:\n",
    "        t = df['Name'][i]\n",
    "        if not t in traj_orientations:\n",
    "            continue\n",
    "        merged_ang_diff = traj_orientations[t]\n",
    "        merged_d = np.exp(df['Speed'][i])/200\n",
    "        #merged_d = (1 - traj_orientation_stds[t])/2 # Longer marker indicates more consistent movement (smaller circular SD)\n",
    "        arrow_vec = (merged_d * np.sin(merged_ang_diff), merged_d * np.cos(merged_ang_diff))\n",
    "        x_center = df['PC1'][i]\n",
    "        y_center = df['PC2'][i]\n",
    "        dx = arrow_vec[0]\n",
    "        dy = arrow_vec[1]\n",
    "        \n",
    "#         x_center = np.mean([traj_vector_K2[t][i][0] for i in range(len(traj_vector_K2[t]))])\n",
    "#         y_center = np.mean([traj_vector_K2[t][i][1] for i in range(len(traj_vector_K2[t]))])\n",
    "#         dx = traj_vector_K2[t][-1][0] - traj_vector_K2[t][0][0]\n",
    "#         dy = traj_vector_K2[t][-1][1] - traj_vector_K2[t][0][1]\n",
    "#         dx = dx/4\n",
    "#         dy = dy/4\n",
    "        \n",
    "        x = x_center - dx/2\n",
    "        y = y_center - dy/2\n",
    "\n",
    "        st = df['State'][i]\n",
    "        if np.max(st) < 0.9:\n",
    "            continue\n",
    "        c = state_cmaps[np.argmax(st)](0.8)\n",
    "        plt.arrow(x, y, dx, dy, color=c, width=0.005, head_width=0.)\n",
    "#         plt.plot([x_center], [y_center], c=c, marker='*', markersize=5.)\n",
    "#         state_lengths[np.argmax(st)].append(np.sqrt(dx**2 + dy**2))\n",
    "\n",
    "    plt.xlabel(\"\")\n",
    "    plt.ylabel(\"\")\n",
    "    plt.xlim(-5, 7)\n",
    "    plt.ylim(-3, 9)\n",
    "    plt.text(bins_PC1[0], bins_PC2[1], legends[well], fontdict={\"size\": 16})\n",
    "    bbox = dict(boxstyle='round', facecolor=(1., 1., 1., 0.5), edgecolor=(0.5, 0.5, 0.5, 0.5), alpha=0.5)\n",
    "    well_prob = np.stack(traj_states[well], 0).mean(0)\n",
    "    plt.text(bins_PC1[-11], \n",
    "             bins_PC2[-2], \n",
    "             'State 1 (blue): %.3f\\nState 2 (red): %.3f' % (well_prob[0], well_prob[1]), \n",
    "             fontdict={\"size\": 10},\n",
    "             bbox=bbox)\n",
    "    plt.tight_layout()\n",
    "#     plt.show()\n",
    "    plt.savefig(\"NOVEMBER_%s_traj_state_PC1_PC2_speed.png\" % well, dpi=300)\n",
    "    plt.savefig(\"NOVEMBER_%s_traj_state_PC1_PC2_speed.eps\" % well)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 252x252 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 252x144 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 252x144 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Histogram of state orientations - patch level ###\n",
    "# orient_states = [[] for _ in range(2)]\n",
    "# displacement_states = [[] for _ in range(2)]\n",
    "# for i_w, well in enumerate(sorted(wells_)):\n",
    "#     df = {'PC1': traj_PC1[well],\n",
    "#           'PC2': traj_PC2[well],\n",
    "#           'Speed': traj_speed[well],\n",
    "#           'State': traj_states[well],\n",
    "#           'Name': traj_names[well]}\n",
    "#     for i in range(len(df['Name'])):\n",
    "#         t = df['Name'][i]\n",
    "#         if not t in traj_orientations:\n",
    "#             continue\n",
    "#         st = df['State'][i]\n",
    "#         traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "#         orient_states[np.argmax(st)].extend([patch_orientations[f] for f in traj_fs if f in patch_orientations])\n",
    "#         displacement_states[np.argmax(st)].extend([patch_displacements[f] for f in traj_fs if f in patch_displacements])\n",
    "\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(3., 3.))\n",
    "# ax = plt.subplot(111, projection='polar')\n",
    "# bins = np.arange(-np.pi/2, np.pi/2 + np.pi/21, np.pi/21)\n",
    "# for i, sts in enumerate(orient_states):\n",
    "#     line, _ = np.histogram(sts, bins=bins)\n",
    "#     _x = (bins[:-1] + bins[1:])/2\n",
    "#     ax.plot(_x, line/sum(line), color=state_cmaps[i](0.8), label='State %d' % (i + 1))\n",
    "# ax.set_theta_zero_location('N')\n",
    "# ax.legend(fontsize=10, loc=(0.28, 0.08))\n",
    "# # plt.show()\n",
    "# plt.savefig(\"NOVEMBER_state_orient.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_state_orient.eps\")\n",
    "\n",
    "### Histogram of state displacements - patch level ###\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(3.5, 2))\n",
    "# bins = np.linspace(0., 6.0, 15)\n",
    "# for i, sts in enumerate(displacement_states):\n",
    "#     line, _ = np.histogram([np.log(s * 0.325 / 0.1518 + 1e-9) for s in sts], bins=bins)\n",
    "#     plt.plot((bins[:-1] + bins[1:])/2, line/sum(line), color=state_cmaps[i](0.8), label='State %d' % (i + 1))\n",
    "# speed_ticks = [1., 10., 100.]\n",
    "# speed_ticks_labels = ['10$^0$', '10$^1$', '10$^2$']\n",
    "# plt.gca().set_xticks(np.log(speed_ticks))\n",
    "# plt.gca().set_xticklabels(speed_ticks_labels)\n",
    "# plt.gca().set_yticks([0., 0.1, 0.2])\n",
    "# plt.legend(fontsize=10, loc=2)\n",
    "# # plt.show()\n",
    "# plt.savefig(\"NOVEMBER_state_displacement.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_state_displacement.eps\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### Histogram of state orientations - traj level ###\n",
    "orient_states = [[] for _ in range(2)]\n",
    "orient_stds_states = [[] for _ in range(2)]\n",
    "displacement_states = [[] for _ in range(2)]\n",
    "for i_w, well in enumerate(sorted(wells_)):\n",
    "    df = {'PC1': traj_PC1[well],\n",
    "          'PC2': traj_PC2[well],\n",
    "          'Speed': traj_speed[well],\n",
    "          'State': traj_states[well],\n",
    "          'Name': traj_names[well]}\n",
    "    for i in range(len(df['Name'])):\n",
    "        t = df['Name'][i]\n",
    "        if not t in traj_orientations:\n",
    "            continue\n",
    "        st = df['State'][i]\n",
    "        # merged_ang_diff = traj_orientations[t]\n",
    "        # orient_states[np.argmax(st)].append(merged_ang_diff)\n",
    "        traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "        orient_states[np.argmax(st)].append(traj_orientations[t])\n",
    "        orient_stds_states[np.argmax(st)].append(traj_orientation_stds[t])\n",
    "        displacement_states[np.argmax(st)].append(np.mean([patch_displacements[f] for f in traj_fs if f in patch_displacements]))\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 3.5))\n",
    "ax = plt.subplot(111, projection='polar')\n",
    "bins = np.arange(-np.pi/2, np.pi/2 + np.pi/41, np.pi/41)\n",
    "for i, sts in enumerate(orient_states):\n",
    "    line, _ = np.histogram(sts, bins=bins)\n",
    "    _x = (bins[:-1] + bins[1:])/2\n",
    "    ax.plot(_x, line/line.sum(), color=state_cmaps[i](0.8), label='State %d' % (i + 1))\n",
    "ax.set_theta_zero_location('N')\n",
    "ax.set_rorigin(-0.15)\n",
    "ax.set_rticks([0., 0.1, 0.2])\n",
    "ax.set_thetagrids([-90, -45, 0, 45, 90])\n",
    "ax.set_thetamin(-90)\n",
    "ax.set_thetamax(90)\n",
    "ax.legend(fontsize=10, loc=(0., 0.7))\n",
    "# plt.show()\n",
    "plt.savefig(\"NOVEMBER_traj_state_orient_polar.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_traj_state_orient_polar.eps\")\n",
    "\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 2.))\n",
    "bins = np.arange(-np.pi/2, np.pi/2 + np.pi/21, np.pi/21)\n",
    "for i, sts in enumerate(orient_states):\n",
    "    line, _ = np.histogram(sts, bins=bins)\n",
    "    _x = (bins[:-1] + bins[1:])/2\n",
    "    plt.plot(_x, line/line.sum(), color=state_cmaps[i](0.8), label='State %d' % (i + 1))\n",
    "plt.gca().set_xticks([-np.pi/2, -np.pi/4, 0, np.pi/4, np.pi/2])\n",
    "plt.gca().set_xticklabels(['-90°', '-45°', '0°', '45°', '90°'])\n",
    "plt.legend()\n",
    "# plt.show()\n",
    "plt.savefig(\"NOVEMBER_traj_state_orient_flat.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_traj_state_orient_flat.eps\")\n",
    "\n",
    "### Histogram of state displacements - traj level ###\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 2))\n",
    "bins = np.linspace(0., 6.0, 15)\n",
    "for i, sts in enumerate(displacement_states):\n",
    "    line, _ = np.histogram([np.log(s * 0.325 / 0.1518 + 1e-9) for s in sts], bins=bins)\n",
    "    plt.plot((bins[:-1] + bins[1:])/2, line/len(sts), color=state_cmaps[i](0.8), label='State %d' % (i + 1))\n",
    "speed_ticks = [1., 10., 100.]\n",
    "speed_ticks_labels = ['10$^0$', '10$^1$', '10$^2$']\n",
    "plt.gca().set_xticks(np.log(speed_ticks))\n",
    "plt.gca().set_xticklabels(speed_ticks_labels)\n",
    "plt.gca().set_yticks([0., 0.1, 0.2, 0.3])\n",
    "plt.legend(fontsize=10, loc=2)\n",
    "# plt.show()\n",
    "plt.savefig(\"NOVEMBER_traj_state_displacement.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_traj_state_displacement.eps\")\n",
    "\n",
    "### Histogram of state orientation stds - traj level ###\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 2))\n",
    "bins = np.linspace(0., 1.0, 20)\n",
    "for i, sts in enumerate(orient_stds_states):\n",
    "    line, _ = np.histogram(sts, bins=bins)\n",
    "    plt.plot((bins[:-1] + bins[1:])/2, line/len(sts), color=state_cmaps[i](0.8), label='State %d' % (i + 1))\n",
    "plt.legend(fontsize=10)\n",
    "# plt.show()\n",
    "plt.savefig(\"NOVEMBER_traj_state_orient_std.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_traj_state_orient_std.eps\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ### Histogram of well orientations - patch level ###\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(3., 3.))\n",
    "# ax = plt.subplot(111, projection='polar')\n",
    "# bins = np.arange(-np.pi/2, np.pi/2 + np.pi/21, np.pi/21)\n",
    "# for i_w, well in enumerate(sorted(wells_)):\n",
    "#     df = {'PC1': traj_PC1[well],\n",
    "#           'PC2': traj_PC2[well],\n",
    "#           'Speed': traj_speed[well],\n",
    "#           'State': traj_states[well],\n",
    "#           'Name': traj_names[well]}\n",
    "#     orient_state = []\n",
    "#     for i in range(len(df['Name'])):\n",
    "#         t = df['Name'][i]\n",
    "#         if not t in traj_orientations:\n",
    "#             continue\n",
    "#         traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "#         orient_state.extend([patch_orientations[f] for f in traj_fs if f in patch_orientations])\n",
    "#     line, _ = np.histogram(orient_state, bins=bins)\n",
    "#     _x = (bins[:-1] + bins[1:])/2\n",
    "#     ax.plot(_x, line/sum(line), color=cmaps[well](0.8), label=legends[well])\n",
    "# ax.set_theta_zero_location('N')\n",
    "# ax.legend(fontsize=8, loc=(0., 0.))\n",
    "# plt.savefig(\"NOVEMBER_well_orient.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_well_orient.eps\")\n",
    "\n",
    "# ### Histogram of well displacement - patch level ###\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(3.5, 2))\n",
    "# bins = np.linspace(0., 6.0, 15)\n",
    "# for i_w, well in enumerate(sorted(wells_)):\n",
    "#     df = {'PC1': traj_PC1[well],\n",
    "#           'PC2': traj_PC2[well],\n",
    "#           'Speed': traj_speed[well],\n",
    "#           'State': traj_states[well],\n",
    "#           'Name': traj_names[well]}\n",
    "#     displacement_state = []\n",
    "#     for i in range(len(df['Name'])):\n",
    "#         t = df['Name'][i]\n",
    "#         if not t in traj_orientations:\n",
    "#             continue\n",
    "#         traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "#         displacement_state.extend([patch_displacements[f] for f in traj_fs if f in patch_displacements])\n",
    "#     line, _ = np.histogram([np.log(s * 0.325 / 0.1518 + 1e-9) for s in displacement_state], bins=bins)\n",
    "#     _x = (bins[:-1] + bins[1:])/2\n",
    "#     plt.plot(_x, line/len(displacement_state), color=cmaps[well](0.8), label=legends[well])\n",
    "    \n",
    "# speed_ticks = [1., 10., 100.]\n",
    "# speed_ticks_labels = ['10$^0$', '10$^1$', '10$^2$']\n",
    "# plt.gca().set_xticks(np.log(speed_ticks))\n",
    "# plt.gca().set_xticklabels(speed_ticks_labels)\n",
    "# plt.gca().set_yticks([0., 0.1, 0.2])\n",
    "# plt.legend(fontsize=8)\n",
    "# plt.savefig(\"NOVEMBER_well_displacement.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_well_displacement.eps\")\n",
    "\n",
    "# ### Histogram of well orientations - traj level ###\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(3., 3.))\n",
    "# ax = plt.subplot(111, projection='polar')\n",
    "# bins = np.arange(-np.pi/2, np.pi/2 + np.pi/21, np.pi/21)\n",
    "# for i_w, well in enumerate(sorted(wells_)):\n",
    "#     df = {'PC1': traj_PC1[well],\n",
    "#           'PC2': traj_PC2[well],\n",
    "#           'Speed': traj_speed[well],\n",
    "#           'State': traj_states[well],\n",
    "#           'Name': traj_names[well]}\n",
    "#     orient_state = []\n",
    "#     for i in range(len(df['Name'])):\n",
    "#         t = df['Name'][i]\n",
    "#         if not t in traj_orientations:\n",
    "#             continue\n",
    "#         orient_state.append(traj_orientations[t])\n",
    "#     line, _ = np.histogram(orient_state, bins=bins)\n",
    "#     _x = (bins[:-1] + bins[1:])/2\n",
    "#     ax.plot(_x, line/sum(line), color=cmaps[well](0.8), label=legends[well])\n",
    "# ax.set_theta_zero_location('N')\n",
    "# ax.legend(fontsize=8, loc=(0., 0.))\n",
    "# plt.savefig(\"NOVEMBER_traj_well_orient.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_traj_well_orient.eps\")\n",
    "\n",
    "# ### Histogram of well displacements - traj level ###\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(3.5, 2))\n",
    "# bins = np.linspace(0., 6.0, 15)\n",
    "# for i_w, well in enumerate(sorted(wells_)):\n",
    "#     df = {'PC1': traj_PC1[well],\n",
    "#           'PC2': traj_PC2[well],\n",
    "#           'Speed': traj_speed[well],\n",
    "#           'State': traj_states[well],\n",
    "#           'Name': traj_names[well]}\n",
    "#     displacement_state = []\n",
    "#     for i in range(len(df['Name'])):\n",
    "#         t = df['Name'][i]\n",
    "#         if not t in traj_orientations:\n",
    "#             continue\n",
    "#         traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "#         displacement_state.append(np.mean([patch_displacements[f] for f in traj_fs if f in patch_displacements]))\n",
    "#     line, _ = np.histogram([np.log(s * 0.325 / 0.1518 + 1e-9) for s in displacement_state], bins=bins)\n",
    "#     _x = (bins[:-1] + bins[1:])/2\n",
    "#     plt.plot(_x, line/len(displacement_state), color=cmaps[well](0.8), label=legends[well])\n",
    "# speed_ticks = [1., 10., 100.]\n",
    "# speed_ticks_labels = ['10$^0$', '10$^1$', '10$^2$']\n",
    "# plt.gca().set_xticks(np.log(speed_ticks))\n",
    "# plt.gca().set_xticklabels(speed_ticks_labels)\n",
    "# plt.gca().set_yticks([0., 0.1, 0.2])\n",
    "# plt.legend(fontsize=8)\n",
    "# plt.savefig(\"NOVEMBER_traj_well_displacement.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_traj_well_displacement.eps\")\n",
    "\n",
    "# ### Histogram of well orientation stds - traj level ###\n",
    "# plt.clf()\n",
    "# f = plt.figure(figsize=(3.5, 2))\n",
    "# bins = np.linspace(0., 1.0, 20)\n",
    "\n",
    "# for i_w, well in enumerate(sorted(wells_)):\n",
    "#     df = {'PC1': traj_PC1[well],\n",
    "#           'PC2': traj_PC2[well],\n",
    "#           'Speed': traj_speed[well],\n",
    "#           'State': traj_states[well],\n",
    "#           'Name': traj_names[well]}\n",
    "#     orient_std_state = []\n",
    "#     for i in range(len(df['Name'])):\n",
    "#         t = df['Name'][i]\n",
    "#         if not t in traj_orientations:\n",
    "#             continue\n",
    "#         orient_std_state.append(traj_orientation_stds[t])\n",
    "#     line, _ = np.histogram(orient_std_state, bins=bins)\n",
    "#     _x = (bins[:-1] + bins[1:])/2\n",
    "#     plt.plot(_x, line/len(orient_std_state), color=cmaps[well](0.8), label=legends[well])\n",
    "# plt.legend(fontsize=8)\n",
    "# plt.savefig(\"NOVEMBER_traj_well_orient_std.png\", dpi=300)\n",
    "# plt.savefig(\"NOVEMBER_traj_well_orient_std.eps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "### Collect samples for each state centers ###\n",
    "center_samples = []\n",
    "prob_mat = get_merged_prob_mat(X, Y, centers, stds, well_prob_mat)\n",
    "for i_c, c in enumerate(centers):\n",
    "    print(i_c)\n",
    "    samples = []\n",
    "    inds = np.where(prob_mat[:, i_c] > 0.8)[0]\n",
    "    for i in inds:\n",
    "        if (np.abs(X[i] - c)/std_unit)[:3].mean() < 0.5:\n",
    "            samples.append(t_arrays[i])\n",
    "    samples = sorted(samples, key=lambda x: (np.array(traj_properties[x][0]).std(0)[:2]).sum())\n",
    "    center_samples.append(samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Sample trajectories with traj marked ###\n",
    "np.random.seed(130)\n",
    "traj_represented = [\n",
    "    'B5-Site_2/16',\n",
    "    'C4-Site_5/143',\n",
    "    'C4-Site_3/23',\n",
    "    'C5-Site_1/98',\n",
    "    'C5-Site_2/307',\n",
    "    'C5-Site_1/299'\n",
    "]\n",
    "cs = [(171, 100, 23)] * 3 + [(26, 20, 188)] * 3\n",
    "\n",
    "for t, c in zip(traj_represented, cs):\n",
    "    well = t[:2]\n",
    "    traj = traj_inds[t]\n",
    "    \n",
    "    site = t.split('/')[0]\n",
    "    image_stack = np.load(os.path.join(raw_folder, '%s.npy' % site))\n",
    "    \n",
    "    t_pos = traj_positions[t]\n",
    "    init_t_point = sorted(t_pos.keys())[0]\n",
    "    init_position = t_pos[init_t_point]\n",
    "    if init_position[0] < 256 or init_position[0] > (2048-256) or init_position[1] < 256 or init_position[1] > (2048-256):\n",
    "        continue\n",
    "\n",
    "    f0 = image_stack[init_t_point, \n",
    "                     (init_position[0]-256):(init_position[0]+256),\n",
    "                     (init_position[1]-256):(init_position[1]+256),\n",
    "                     0]\n",
    "    \n",
    "    f0 = enhance_contrast(f0, phase_a, phase_b)\n",
    "    mat = np.zeros((f0.shape[0], f0.shape[1], 3), dtype='uint8')\n",
    "    mat[:, :] = (np.expand_dims(f0, 2) / 256).astype('uint8')\n",
    "    try:\n",
    "        t_pos = traj_positions[t]\n",
    "        positions = np.stack([t_pos[k] for k in sorted(t_pos.keys())])\n",
    "        center_position = positions[0] - np.array([256, 256])\n",
    "        for i in range(positions.shape[0] - 1):\n",
    "            start = positions[i] - center_position\n",
    "            end = positions[i + 1] - center_position\n",
    "            mat = cv2.line(mat, (start[1], start[0]), (end[1], end[0]), c, thickness=2)\n",
    "        cv2.imwrite('NOVEMBER_center_sample_%s.png' % t.replace('/', '_'), mat)\n",
    "    except Exception as e:\n",
    "        print(e)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Calcualte Trajectory MSDs ###\n",
    "MSD_length = 30\n",
    "\n",
    "# MSD by states\n",
    "center_cut_ensembles = []\n",
    "for i_c, c in enumerate(centers):\n",
    "    target_trajs = center_samples[i_c]\n",
    "    cut_ensemble = []\n",
    "    for t in target_trajs:\n",
    "        t_end = max(traj_positions[t].keys()) + 1\n",
    "        for t_start in range(t_end - MSD_length):\n",
    "            if t_start in traj_positions[t]:\n",
    "                s_traj = {(t_now - t_start): traj_positions[t][t_now] \\\n",
    "                    for t_now in range(t_start, t_start+MSD_length) if t_now in traj_positions[t]}\n",
    "                cut_ensemble.append(s_traj)\n",
    "    center_cut_ensembles.append(cut_ensemble)\n",
    "\n",
    "center_MSDs = [{i: [] for i in range(MSD_length)} for _ in range(len(centers))]\n",
    "for i_c, cut_ensemble in enumerate(center_cut_ensembles):\n",
    "    for cut in cut_ensemble:\n",
    "        for i in range(MSD_length):\n",
    "            if i in cut:\n",
    "                center_MSDs[i_c][i].append(np.square(cut[i] - cut[0]).sum() * 0.325**2) # unit of um^2\n",
    "\n",
    "# MSD all and MSD by well\n",
    "all_cut_ensembles = []\n",
    "well_cut_ensembles = {w: [] for w in wells_}\n",
    "for t in trajs:\n",
    "    well = t[:2]\n",
    "    if not well in wells_:\n",
    "        continue\n",
    "    t_end = max(traj_positions[t].keys()) + 1\n",
    "    for t_start in range(t_end - MSD_length):\n",
    "        if t_start in traj_positions[t]:\n",
    "            s_traj = {(t_now - t_start): traj_positions[t][t_now] \\\n",
    "                for t_now in range(t_start, t_start+MSD_length) if t_now in traj_positions[t]}\n",
    "            all_cut_ensembles.append(s_traj)\n",
    "            well_cut_ensembles[well].append(s_traj)\n",
    "\n",
    "all_MSDs = {i: [] for i in range(MSD_length)}\n",
    "for cut in all_cut_ensembles:\n",
    "    for i in range(MSD_length):\n",
    "        if i in cut:\n",
    "            all_MSDs[i].append(np.square(cut[i] - cut[0]).sum() * 0.325**2) # unit of um^2\n",
    "\n",
    "\n",
    "well_MSDs = {w: {i: [] for i in range(MSD_length)} for w in wells_}\n",
    "for w, cut_ensemble in well_cut_ensembles.items():\n",
    "    for cut in cut_ensemble:\n",
    "        for i in range(MSD_length):\n",
    "            if i in cut:\n",
    "                well_MSDs[w][i].append(np.square(cut[i] - cut[0]).sum() * 0.325**2) # unit of um^2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State 1: 169.811290 * t ^ (0.883765)\n",
      "0.9970488672296928\n",
      "State 2: 633.921190 * t ^ (0.929082)\n",
      "0.9981241444767347\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x345.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Plot MSD ###\n",
    "from matplotlib.ticker import NullLocator\n",
    "import sklearn\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "x = np.log(np.arange(1, MSD_length) * 0.1518) # log of hour\n",
    "    \n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 4.8))\n",
    "for i_c, MSDs in enumerate(center_MSDs):\n",
    "    y_center = [np.log(np.mean(MSDs[i])) for i in np.arange(1, MSD_length)] # log of um^2\n",
    "    reg = LinearRegression(fit_intercept=True).fit(x.reshape((-1, 1)), np.array(y_center))\n",
    "    print(\"State %d: %f * t ^ (%f)\" % (i_c + 1, np.exp(reg.intercept_), reg.coef_[0]))\n",
    "    y_pred = x * reg.coef_ + reg.intercept_\n",
    "    print(sklearn.metrics.r2_score(y_pred, y_center))\n",
    "    plt.plot(x, y_center, '.', c=state_cmaps[i_c](0.8), label=\"State %d\" % (i_c + 1))\n",
    "    plt.plot(x, y_pred, '--', c=state_cmaps[i_c](0.8), linewidth=0.8)\n",
    "xticks = np.array([0.25, 0.5, 1, 2, 4]) # hour\n",
    "yticks = np.array([10, 100, 1000, 10000]) # um^2\n",
    "yticks_labels = [ '10$^1$', '10$^2$', '10$^3$', '10$^4$']\n",
    "yticks_positions = np.log(yticks) # same adjustment for imshow\n",
    "plt.gca().set_xticks(np.log(xticks))\n",
    "plt.gca().set_xticklabels(xticks)\n",
    "plt.gca().xaxis.set_minor_locator(NullLocator())\n",
    "plt.gca().set_yticks(yticks_positions)\n",
    "plt.gca().set_yticklabels(yticks_labels)\n",
    "plt.legend()\n",
    "# plt.show()\n",
    "plt.savefig(\"NOVEMBER_state_MSD.png\", dpi=300)\n",
    "plt.savefig(\"NOVEMBER_state_MSD.eps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:18: RuntimeWarning: invalid value encountered in true_divide\n",
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:45: UserWarning: aspect is not supported for Axes with xscale=log, yscale=linear\n",
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:59: UserWarning: aspect is not supported for Axes with xscale=log, yscale=linear\n",
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:60: UserWarning: aspect is not supported for Axes with xscale=log, yscale=linear\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:18: RuntimeWarning: invalid value encountered in true_divide\n",
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:45: UserWarning: aspect is not supported for Axes with xscale=log, yscale=linear\n",
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:59: UserWarning: aspect is not supported for Axes with xscale=log, yscale=linear\n",
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:60: UserWarning: aspect is not supported for Axes with xscale=log, yscale=linear\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/michaelwu/anaconda3/lib/python3.6/site-packages/IPython/core/pylabtools.py:132: UserWarning: aspect is not supported for Axes with xscale=log, yscale=linear\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Plot MSD2 ###\n",
    "from matplotlib.ticker import NullLocator\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "def plot_density_map(MSD_list, cmap, label='None'):\n",
    "    x = np.arange(1, MSD_length)\n",
    "    y_bins = np.arange(0., 10.2, 0.6)\n",
    "    density_map = np.zeros((MSD_length, len(y_bins) - 1))\n",
    "    y = []\n",
    "    for i in range(1, MSD_length):\n",
    "        for d in MSD_list[i]:\n",
    "            if d == 0: \n",
    "                continue\n",
    "            ind_bin = ((np.log(d) - y_bins) > 0).sum() - 1\n",
    "            if ind_bin < density_map.shape[1] and ind_bin >= 0:\n",
    "                density_map[i][ind_bin] += 1\n",
    "        y.append((np.log(np.mean(MSD_list[i])) - y_bins[0])/(y_bins[1] - y_bins[0]))\n",
    "    density_map = density_map/density_map.sum(1, keepdims=True)\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(121)\n",
    "    ax.imshow(np.transpose(density_map), cmap=cmap, origin='lower', vmin=0.01, vmax=0.3, alpha=0.5)\n",
    "    ax.plot(x, np.array(y) - 0.5, '.', c=cmap(0.8), markersize=2.5, label=label) # -0.5 is the adjustment for imshow\n",
    "    \n",
    "    reg = LinearRegression(fit_intercept=True).fit(np.log(x).reshape((-1, 1)), np.array(y))\n",
    "    y_pred = np.log(x) * reg.coef_ + reg.intercept_\n",
    "    ax.plot(x, y_pred - 0.5, '--', c=cmap(0.8), linewidth=0.8)\n",
    "    ax.legend()\n",
    "    \n",
    "    xticks = np.array([0.25, 0.5, 1, 2, 4]) # hour\n",
    "    xticks_positions = xticks / 0.1518\n",
    "    yticks = np.array([1, 10, 100, 1000, 10000]) # um^2\n",
    "    yticks_labels = ['10$^0$', '10$^1$', '10$^2$', '10$^3$', '10$^4$']\n",
    "    yticks_positions = (np.log(yticks) - y_bins[0])/(y_bins[1] - y_bins[0]) - 0.5 # same adjustment for imshow\n",
    "\n",
    "    ax.set_xlim(0.125 / 0.1518, 4.6 / 0.1518)\n",
    "    ax.set_xscale('log')\n",
    "    ax.set_xticks(xticks_positions)\n",
    "    ax.set_xticklabels(xticks)\n",
    "    ax.xaxis.set_minor_locator(NullLocator())\n",
    "    ax.set_yticks(yticks_positions)\n",
    "    ax.set_yticklabels(yticks_labels)\n",
    "    ax.set_xlabel('')\n",
    "    ax.set_ylabel('')\n",
    "    plt.tight_layout()\n",
    "\n",
    "# plt.clf()\n",
    "# plot_density_map(all_MSDs, cmap=cmaps['all'], label='All')\n",
    "# plt.savefig(\"MSD_all_trajs.png\", dpi=300)\n",
    "\n",
    "# for w, MSDs in well_MSDs.items():\n",
    "#     plt.clf()\n",
    "#     plot_density_map(MSDs, cmap=cmaps[w], label=legends[w])\n",
    "#     plt.savefig(\"MSD_%s_trajs.png\" % w, dpi=300)\n",
    "\n",
    "for i_c, MSDs in enumerate(center_MSDs):\n",
    "    plt.clf()\n",
    "    plot_density_map(MSDs, cmap=state_cmaps[i_c], label=\"State %d\" % (i_c + 1))\n",
    "    plt.savefig(\"MSD_state_%d_trajs.png\" % i_c, dpi=300)\n",
    "    plt.savefig(\"MSD_state_%d_trajs.eps\" % i_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Generate Traj Vectors ###\n",
    "t_lag = 1\n",
    "traj_vector_latent_vector = {}\n",
    "traj_vector_motion = {}\n",
    "\n",
    "# full_dats = {}\n",
    "# for well in wells:\n",
    "#     path = os.path.join(raw_folder, '%s_latent_space.pkl' % well)\n",
    "#     full_dats[well] = pickle.load(open(path, 'rb'))\n",
    "\n",
    "# Use K-way vectors\n",
    "K = [5, 3, 1]\n",
    "feat_name = [[], []]\n",
    "write_feat_name = True\n",
    "for t in trajs:\n",
    "    well = t[:2]\n",
    "    if not well in wells:\n",
    "        continue\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "    assert len(t_keys) == len(traj_fs)\n",
    "    dists = {}\n",
    "    dists_ang = {}\n",
    "    cell_ang = {}\n",
    "    for i, t_point in enumerate(t_keys):\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = traj_positions[t][t_point+t_lag] - traj_positions[t][t_point]\n",
    "            d_ang = cmath.polar(complex(d[1], d[0]))[1]\n",
    "            dists[t_point] = d\n",
    "            dists_ang[t_point] = d_ang\n",
    "            cell_ang[t_point] = cell_aps[traj_fs[i]][1]\n",
    "\n",
    "    #traj_full_dats = np.stack([full_dats[well][ind] for ind in traj_inds[t]], 0)\n",
    "    traj_full_dats = np.stack([dats[well][ind] for ind in traj_inds[t]], 0)\n",
    "    traj_vector_latent_vector[t] = []\n",
    "    traj_vector_motion[t] = []\n",
    "    for k in K:\n",
    "        segs = np.linspace(0, len(traj_full_dats), k+1).astype(int)\n",
    "        vs = []\n",
    "        ds = []\n",
    "        for i in range(len(segs) - 1):\n",
    "            v = traj_full_dats[segs[i]:segs[i+1]].mean(0)[:15]\n",
    "#             v = traj_full_dats[np.random.randint(segs[i], segs[i+1])]\n",
    "            vs.append(v)\n",
    "    \n",
    "            _d =  [dists[t_point] for t_point in t_keys[segs[i]:segs[i+1]] if t_point in dists]\n",
    "            _ang = [(dists_ang[t_point] - cell_ang[t_point]) % (np.pi) for t_point in t_keys[segs[i]:segs[i+1]] if t_point in dists]\n",
    "            mean_absolute_d = np.mean([np.linalg.norm(d, ord=2) for d in _d])\n",
    "            accumulate_d = np.linalg.norm(sum(_d), ord=2)\n",
    "            merged_x = sum([np.linalg.norm(d, ord=2) * np.cos(2 * ang) for d, ang in zip(_d, _ang)])\n",
    "            merged_y = sum([np.linalg.norm(d, ord=2) * np.sin(2 * ang) for d, ang in zip(_d, _ang)])\n",
    "            merged_d, merged_ang_diff = cmath.polar(complex(merged_x, merged_y))\n",
    "            ds.append([mean_absolute_d, accumulate_d, merged_d, merged_ang_diff])\n",
    "            \n",
    "            if write_feat_name:\n",
    "                feat_name[0].extend([\"PC%d_segment_%d_%d\" % (_+1, k, i) for _ in range(15)])\n",
    "                feat_name[1].extend(['MA_D_segment_%d_%d' % (k, i), \n",
    "                                     'ACC_D_segment_%d_%d' % (k, i),\n",
    "                                     'ANG_D_segment_%d_%d' % (k, i),\n",
    "                                     'ANG_segment_%d_%d' % (k, i)])\n",
    "        traj_vector_latent_vector[t].append(np.concatenate(vs))\n",
    "        traj_vector_motion[t].append(np.concatenate(ds))\n",
    "    traj_vector_latent_vector[t] = np.concatenate(traj_vector_latent_vector[t])\n",
    "    traj_vector_motion[t] = np.concatenate(traj_vector_motion[t])\n",
    "    if write_feat_name:\n",
    "        write_feat_name = False\n",
    "        feat_name = np.concatenate(feat_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B2', 'C5']\n",
      "0.7395195478097033\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPgAAAD4CAYAAADB0SsLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAStUlEQVR4nO3deXSU9dmH8esOAQIBQzAQdiMiigsCRhBfQBGxr62FioCoFepBbalKkVpLV60ej9trFdyxrZWqWAEFBW0rO1RKAAUFxCIKsiZsBkVQTO73jxliEiATzEwSfvl+zuGYZ5u5x+HieWYyBHN3RCRMSVU9gIgkjgIXCZgCFwmYAhcJmAIXCVhyou+gVr00r52Wmei7kThqlp5S1SPIUdqw5r0d7t6k9PqEB147LZM2Q8cl+m4kjsYM7FDVI8hRGt4ta8Ph1usSXSRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYMllbTSzAWVtd/eX4zuOiMRTmYEDk4Hl0V8AVmybAwpcpBqLFfjlwBVAR2AaMNHdP0z4VCISF2W+Bnf3V9x9CHA+sA540MwWmtn5lTKdiFRIed9k2w/kA3uAVCAlYROJSNzEepOtN3Al0BWYCYx196WVMZiIVFys1+CzgHeBhUBdYKiZDT240d1HJnA2EamgWIFfWylTVIKe7TP4Tf8O1DKYlLOJ8XM/PmSfSzo24+a+7XB31mz9jJ9PfBeA5o1SuHvgGTRPS8GB6/+yjM2791XyI6h53ls0l4l/vBMvLKBnvyv47rCfltg+9+XnmD35byQlJVG3XirDfnUPLdqeXLR957bN/G5IX/pdN4r//eENlT1+tVBm4O7+bGUNkkhJBrdfdhrXPr2Ebfn7mXJzd2atzmNd3t6ifU7IqM+Pe7dlyOP/Yc++r2mcWqdo2/1XdOSJ2et4a+1O6tepRaF7VTyMGqWwoIDnH/g9P3/kOdKbNuOuH/WjU8++JQLudnF/LhjwQwCWz3+Tv4+9i1vGTija/uJDd3FG9wsqe/Rqpcw32cwsw8xuN7ORZtbAzJ4ws5VmNs3M2pVx3A1mttTMlhbsy4//1EepY+tGbNjxBRt37eNAgTNjxTYuOj2zxD6Du7bi+UWfsGff1wDs2vsVACc1TSU5yXhr7U4AvviqgP0HCiv3AdRAH61eTtNWJ9CkZRuSa9eha9/v8878f5XYp16DhkVff7nvC7BvPqbx9rx/0qRlG1oW+wOhJor1LvoLRF57nwzkAB8BA4HpwJ+OdJC7j3f3bHfPrlUvLV6zfmuZaXXZlv/NJfW2/P1kHle3xD4nZqSSlVGfiT/txks3nkvP9hmR9U1S2bP/AI9e04mpPzuP2753CkmGJNinebk0zmxRtJzetDmfbs89ZL/ZkyYwZkAvJj16L1eNvgOIxP7GhCfpd93PKmvcaitW4Jnu/mtgJNDA3R9w9zXu/jTQKPHjxcfheix9kV2rlpGVkco1T+Yw+oUV3D3wDBqmJFMrycjOSue+GR9w+SOLaN24HgOyW1bG2DWaH/IMUeIMfdCFg4Zy78vzGXjTGKY/8wgAU8c/xMVXDielfmqix6z2Yr3JVgDg7m5mO0ptO2auU7flf0mztHpFy83SUsjb82WpffazfEM+Xxc6m3bv4+Pte8nKqM+2/P2s3vIZG3dFrgBmrsqjU5s0Ji/ZXKmPoaZJb9qMXblbipZ3522lUUbTI+7fte/3ee6+3wLw8arlLJvzOpMevYcvPtuDJSVRu25d+gwalvC5q5tYgbc1s1eJnAQPfk10+cSEThZH723KJyujPq3S65G7Zz/fO6sZo6PvkB80c2Uel3ZqzivLNpNevzZZTeqzcdc+9uw7QFq9ZNJTa7N77wHOPakxKzftqaJHUnOc2OEscjeuZ/uWjaQ3ySTnzde44a5xJfbJ/eRjMttEfhu+++/ZNG2dBcCY8ZOK9pn29EPUrZdaI+OG2IH3L/b1/0X/66WWq72CQufOaav583XZ1EoyJi/ZxIe5nzPy4nas3JTP7NXbWfDfHfRon8HrP+9BQaFz/4wP+PSLAwDcO+MDnr2hKwas2ryHl3I2Vu0DqgFqJSdz9a138tDIoRQWFtDj+4Np2bY9U5/6I1kdzqRTr77MmvQs7y/5N7WSk6nfMI3htz9Y1WNXO+ZlfMvHzPoDrdz9sehyDtCESOS/dPdJRzw4KqVZe28zdFys3aQaGTOwQ1WPIEdpeLesZe6eXXp9rDfZbgNeLbZcB8gGLgB+ErfpRCQhYl2i13H34tejC919J7DTzPQWpUg1F+sMnl58wd1vKrbYJP7jiEg8xQp8sZldX3qlmf2YyAdfRKQai3WJfgsw1cyuAt6OrjubyKfbfpDIwUSk4mL9ZZM84DwzuxA4Pbp6hrvPTvhkIlJhsc7gAESDVtQixxj9XHSRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgCUn+g7aNkllwojuib4biaOeI1+o6hEkTnQGFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJWHJZG82sS1nb3f3t+I4jIvFUZuDAg2Vsc+DCOM4iInFWZuDu3ruyBhGR+It1BgfAzGoDI4Be0VVzgafc/UCC5hKROChX4MATQG3g8ejyNdF11yViKBGJj/IGfo67n1VsebaZrUjEQCISP+X9NlmBmZ10cMHM2gIFiRlJROKlvGfwXwBzzOwjwIATgGsTNpWIxEXMwM0sCdgHnAycQiTwNe7+ZYJnE5EKihm4uxea2YPu3h14txJmEpE4Ke9r8H+Z2eVmZgmdRkTiqryvwUcDqcDXZrafyGW6u/txCZtMRCqsXIG7e8NEDyIi8VeuS3Qzm1WedSJSvZQZuJmlmFljIMPM0s2scfRXFtCiMgaMl7fmzeTyPtlc1rszf33ioUO2P/+nRxl8cTeuvOQ8Rlzdj62bPynaNn3KCwzo3YUBvbswfcoLlTl2jda3S2tWPHElK5+6ilsHdj5ke+smDfjH3f1Y9PBAcsYN5jtntynaduvAzqx86ipWPHElF3VuXZljVyuxzuA/BpYBp0b/e/DXNOCxIx1kZjeY2VIzW7p71854zfqtFRQUcP/ttzL2mcm89M/F/Ou1yXy0dk2JfU45vSMTps1h4htv0eeS/oy793YA8j/dzdPj7uOZV2bx16mzeXrcfezJ/7QqHkaNkpRkPPyTnvS/Yzqdb3yRQb3acWrr9BL7/HLw2UxZuI7uoyYz9IE3GTuiJwCntk5nUK92dLnxRfrdMZ2xI3qSlFQz3x8uM3B3H+vuJwK3untbdz8x+ussd3+0jOPGu3u2u2enNz4+7kMfrVUrltH6hLa0apNF7Tp16Hvp5cx78/US+2R370VKvfoAnNk5m7xtWwD4z/xZdOvRm7RG6RyX1ohuPXqzaN7MSn8MNc05Jzdl3dZ81ud+xoGvC5k0/0Mu7ZZVYh/HOa5+bQDS6tdh664vALi0WxaT5n/IV18XsiH3M9Ztzeeck5tW9kOoFsr7JtsjZnYekFX8GHefkKC54mr7tq1kNm9ZtJzZvAUrly874v7TXnqO886/CIC83JLHNm3WgrzcrYkbVgBocXwqm3bsLVrevHMvXduXjPTuF5by2p2XMuLSM6mfUpvv/fZVAFoen8riD3K/OXbHXlocn1o5g1cz5f3ron8DTgKW881n0B04JgJ3/JB1R/qO/utT/877773DUxNnRA8u/7ESP4f7f1z6qRjcqx3PzfqAsVNX0O2UTP48ug9n3/T3wx586LNYM5T3++DZwGnuh/ndfgxo2qwFuVs3Fy3nbt1CRtPmh+y3eOFcnnnsQZ6aOIM6desWHbts8cKiffK2beHsbj0SP3QNt3nHXlplfHPWbXl8Klt27S2xz7CLO9D/9ukALP4gl5Q6yWQcV4/NOz6nVUaDb47NSGXrzpLH1hTl/STbSqBZIgdJpNM6duGT9evYvHE9B776ijenT6HXRZeU2OeDVSu457ejeHD8RBpnNClaf26vPixeMJs9+Z+yJ/9TFi+Yzbm9+lT2Q6hxlq7No12LRpyQ2ZDayUkM6tWOGTnrS+yzcfvnXHBWKwBOadWIlNq12J6/jxk56xnUqx11kpM4IbMh7Vo0YsnavCp4FFWvvGfwDGC1meUARX/JxN37JWSqOEtOTua2Ox5g5LDLKSgsoN+gH3JS+w48+dDddDizM+df9F3G3vN79u3dy5ibhgHQrEUr/vj0i6Q1Smf4Tb9g2A8iP71q+M23kdYovay7kzgoKHRueXIBr/3hUmolGc/OXMP7n+zmd1efw9trtzMjZz1j/vwWj990Pjf374g7XD92NgDvf7KbKQvX8c7jQ/i6wBn15AIKC4/Ji88Ks/JcdZvZ+Ydb7+7zYh172pmdfcKrc49+MqkyPUfqe/3Hmv3Tf7rM3bNLry/vu+jzzCwTOCe6Ksfda+Y1j8gxpLwfVR0M5ACDgMHAYjMbmMjBRKTiyvsa/DdEfi5bHoCZNQFmApMTNZiIVFx530VPKnVJvvMojhWRKlLeM/g/zOyfwMTo8hXA62XsLyLVQKx/m6wdkOnuvzCzAUAPIj/sYRHwfCXMJyIVEOsy+2HgMwB3f9ndR7v7LUTO3g8nejgRqZhYgWe5+yE/aNHdlxL5iyciUo3FCjyljG314jmIiMRfrMCXmNn1pVea2XAiP/hBRKqxWO+ijwJeMbOr+SbobKAOcFkiBxORiov174PnAueZWW/gjOjqGe4+O+GTiUiFlfez6HOAOQmeRUTiTJ9GEwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYuXti78BsO7AhoXdSdTKAHVU9hJRbyM/XCe7epPTKhAceMjNb6u7ZVT2HlE9NfL50iS4SMAUuEjAFXjHjq3oAOSo17vnSa3CRgOkMLhIwBS4SMAVeipllmtkLZvaRmS0zs0VmdpmZXWBm+Wa23MzeNbOZZtY0esyPzMzNrE+x27ksum5g1T2asJhZMzN70czWmdlqM3vdzNp/i9sZZWb1v8Vxc83smPo2mwIvxswMmArMd/e27n42MARoFd1lgbt3cveOwBLgxmKHvwdcWWx5CLCiEsauEaLPzSvAXHc/yd1PA34NZH6LmxsFHDZwM6v17aesfhR4SRcCX7n7kwdXuPsGd3+k+E7R32wNgd3FVi8AuppZbTNrALQDllfCzDVFb+BAqedmObDQzB4ws5Vm9p6ZXQEQveKaa2aTzWyNmT1vESOBFsAcM5sT3fdzM7vTzBYD3c2sj5m9E729v5hZ3Sp4vHGRXNUDVDOnA2+Xsb2nmS0Hjgf2EjmDHOTATOA7QBrwKnBiguasic4Alh1m/QCgE3AWkY+iLjGz+dFtnYk8p1uAfwP/4+7jzGw00NvdD35sNRVY6e6/N7MUYC3Qx93/a2YTgBHAw4l6YImkM3gZzOwxM1thZkuiqw5eorcGngHuL3XIi0QuzYcAEytx1JqsBzDR3QvcPReYB5wT3Zbj7pvcvZDI1VTWEW6jAJgS/foU4GN3/290+VmgV0ImrwQKvKRVQJeDC+5+I9AHOORD/ETO0CWeeHfPIXKmySj2G0TiYxVw9mHWWxnHfFns6wKOfMW6390LynF7xxwFXtJsIMXMRhRbd6R3W3sA6w6z/leUvHSX+JgN1DWz6w+uMLNziLwPcoWZ1TKzJkT+0M2JcVufEXkP5XDWAFlm1i66fA2Rq4Jjkl6DF+PubmY/AB4ys9uA7URea/8yusvB1+AG5APXHeY23qiseWuS6HNzGfCwmY0B9gPribwj3oDIdywcuM3dt5nZqWXc3HjgDTPb6u69S93PfjO7FphkZslEvlvy5OFu5Figj6qKBEyX6CIBU+AiAVPgIgFT4CIBU+AiAVPgIgFT4CIB+3/3AxA4MSVVnwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B4', 'C5']\n",
      "0.7287157287157288\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B5', 'C5']\n",
      "0.8289131565262611\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B2', 'B4']\n",
      "0.6875\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B2', 'B5']\n",
      "0.7121026894865525\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B4', 'B5']\n",
      "0.6878140703517588\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPgAAAD4CAYAAADB0SsLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAARMklEQVR4nO3deXxU9bnH8c+ThAAJO0kgQCAgYgGBVAGLqKVat7YuaKlabe2tFb1Waa1LXdpeLF6t2kpxrdy21wVBRatW1Lqv6BVQ2RVQBAkGkB0lCCRP/8iQO0AyCTBnhvzyfb9eeSXnzBnmGYZPzjmTyWDujoiEKSPdA4hIdBS4SMAUuEjAFLhIwBS4SMCyor6BjGatPKtlQdQ3I0nUtSA33SPIHvp4/uzV7p6/6/rIA89qWUDe6TdHfTOSRH+8aEi6R5A9NHxAp6U1rdchukjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMAUuEjAFLhIwBS4SMASBm5m/VM1iIgkX1178PfN7CMzG2NmfVIykYgkTV2BzwZOjW33TzObZWZXmVlx1IOJyL6rK3B397nufq279wTOBwqAN8zsrejHE5F9kVXH5Ra/4O7TgGlmdhlwVGRTiUhS1BX4LTWtdHcHXkv+OCKSTAkDd/eJqRokasP6dGDMD/qTkWFMmrqEO55buNPlo0f0Y2ivfACaZWeS17IpvX81BYAHLxnKId3bMu2jNZx719spn72xem/qK/ztpt9SWVnJt4efxennXbLT5U/efw8vPj6RzMwsWrVtz8XX3UpBpy4A3D/2ema88RIAPxj5S4444ZSUz78/qGsPXisze9bdT0zmMFHJMLjhrAGcOe5NytaV88zV3+K52WUsKttUvc3oyXOqv/7psB4cXNSmevnu5xfSPDuTc47sntK5G7OKigrG33ANo+95iPYdCrnyh99h8LDjKTqgV/U2Pb52MH+c+CxNm+fwr0fu4/6xY7j8lnuY8fqLLP5wDmMfeYFtW7fym/NO45AjjianRcs03qP0qOvn4IfU8nEoUJLgeiPNbIaZzajcsiHpQ++prxe3Y8mqL/l09Wa2VThPTi/l+P6FtW5/6qAinphRWr385oLP+eKr7akYVWIWzX2fwqJiOnbpRpMm2RxxwilMe/W5nbbpN3goTZvnANCr3yGsWVUGwLLFC+l76BAys7JolpNDca8+vD/1lZTfh/1BXXvw6VSda1sNl7WpYR0A7j4eGA+Qnd/T93q6JOnYthmfrSuvXi5bX84h3dvVuG3nds0pysvlzQ9XpWo8qcHaVSvI69iperl9QSEL57xX6/YvPj6JQ4YeDUD3Xn14+J5bOflHI/lqSzlzp79FUY9etV43ZHUF/gFwgbsv2vUCM1sWzUjJZzV8f/Javu2cOrCIp99bTmXavy01bl7DA2RW034GXp3yGB/Pn831f38MgJLDh7Fo3iyuOvdkWrdtz0EDDiUja6/PRhu0un4OPjrBNpfUsn6/U7aunE5tm1cvF7Zpzor15TVue8rALjwxvcF87wpW+w6FrF7xWfXymlVltCvouNt2s/7vdR796ziuHncvTbKbVq8fcf4vGPvIi4y+52HcnU5dG+fzJwkDd/dH3X1BLRdnRjBPJGYuXUf3ghYUtc+hSaZxyqAuPD+7bLftDujQgta5TZixeG0appR4B/YtoezTT1hZ+inbtm3lzX89yaBvHrfTNos/mMPdY37NNePupU37vOr1FRUVbFxf9RguWTifJQs/oGTIN1M6//5iX45bxgKPJWuQKFVUOtc+PJOJo4aSmWE89NZSFpZt4oqTejNr6frq2E8dVMST00t3u/7jlx1Fz44tyWmaxYwbT+SyB97ltfk6R49SZlYW51/931z3nz+ksrKCY049k649D2LinTfTs+8ABg87nvvGjmHL5i+55YqRAOR37Mw1t91HxfZtXPsfwwHIyW3JpTfcTmYjPUS3ms516nVFs2XuXlTXdtn5PT3v9Jv36jYkPe66aEi6R5A9NHxAp3fdfeCu6/fl98H1NJTIfi7hcYuZzaHmkA3oEMlEIpI0dZ2YfC8lU4hIJOp6LfrSVA0iIslX1yH6Jmo/RHd3bxXJVCKSFHXtwRvfq/NFAqJ3VRUJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCZgCFwmYAhcJmAIXCVhW1DfQKS+H3/300KhvRpLoigdmpnsESRLtwUUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFAqbARQKmwEUCpsBFApZV1wZmlg/8GugDNNux3t2PjnAuEUmC+uzBHwQ+ALoD1wFLgOkRziQiSVKfwNu7+9+Abe7+mrv/FPhGxHOJSBLUeYgObIt9LjOz7wKfAV2iG0lEkqU+gV9vZq2By4DbgVbALyOdSkSSoj6Br3P3DcAG4FsAZjY00qlEJCnqcw5+ez3Xich+ptY9uJkNAQ4H8s3sV3EXtQIyox5MRPZdokP0bKBFbJuWces3At+PcigRSY5aA3f314DXzOxed19qZrnu/mUKZxORfVSfc/BOZjafqhe7YGYDzOyuaMcSkWSoT+B/Bo4H1gC4+yzgqCiHEpHkqNcvm7j7sl1WVUQwi4gkWX1+Dr7MzA4H3MyygVHEDtdFZP9Wnz34hcDPgc7AcqAktiwi+7k69+Duvho4OwWziEiS1bkHN7MeZvaUmX1uZqvM7Ekz65GK4URk39TnHHwicCcwPLZ8JjAJOCyqoaIw5+1XmXTr7/HKCo48+Qy+c+5FO13+6j8m8PKjD5CRkUHT5rmce/WNdOpxYPXla1Ys57dnHsvJP/slJ5wzMtXjN0pHHpTHb07uTWaG8ci0Usa/sni3bU7s35FRxx2Iu/Nh2SZ+NXEWAIVtmnHDiH4Utm6GAz/72wyWrytP8T1Iv/oEbu7+QNzyBDO7OOEVzEYCIwHad+y8D+MlR2VFBQ/e8jsuu30CbQs6MuYnJ1Ny5LE7BXzYcacw7LRzAJj5+gs8PG4Ml467v/ryh8aO4eAhw1I9eqOVYTB6eF9+Mn4aKzZs4bFRh/PyvFV8tOqL6m265eVw4dEHcMadb7OxfDvtcrOrL7vlzP7c/dLHTF20hpzsTCrd03E30q7WQ3Qza2dm7YBXzOwqMys2s25mdiXwdKI/1N3Hu/tAdx/Yok27ZM+8xxbPn0lBl27kd+5KVpNsBh97Eu+//vxO2zRv8f+vxv2qfDOYVS+/99pz5HfuSue4bwgSrf5d27B09ZcsW1vOtgrn6ZllHNO3YKdtzjisiAlvLWVj+XYA1n65FYCeBS3IzDCmLloDwOatFWzZVpnaO7CfSLQHfxdwYMe/9AviLnNgTFRDJdv6VStp16FT9XLbgkI+mTdzt+1ennw/z0/6K9u3beOKOycCVbE/e/9fuOz2CTz34PiUzdzYdWzVjLL1W6qXV2zYwoCubXbapjgvF4CHfv4NMs247YVFvLFgNcX5OWwq386dP/46Xdrl8Nai1dzyzAIqG+FOvNY9uLt3d/cesc+7fjSoJ9mcGh7ZuD30DkeP+DF/+MfrfP/iq5jyv1W/EfvE+LEcd9Z5NMvJjXpMibf7w4PvcpidlWF0y8vhnLvf4dIHZ3LD9/vRslkWWRkZDOzelj9M+ZDTbnuLovY5nDawcb4JUX3OwRu8tgUdWbvys+rldavKaJNXUOv2g489iQk3/QaAT+bN5N1XnmHyHTeyedNGLCODJk2bcsyIcyOfuzFbsWELhW2q38SXjq2bsWrjV7ttM/PT9WyvdErXlbP48y8ozstlxYYtzP9sI8vWVj2p9sLclZR0a8OjjfCtQhtF4N17D2DlsiV8/tky2uZ3YNoLTzFyzG07bbPy00/o0LU7ALOnvkxBUTEAV42fXL3Nk/8zlqbNcxV3CsxZtoHivFy6tG3Oyo1b+G5JYfUz5Du8MG8l3ysp5B8zltM2pwnd83NZtnYzG8u30ap5E9rlZrP2y60M6dmeOaUb0nRP0qtRBJ6ZlcXZl/+esaN+TGVlBUec9AM69+jFE/fcSnHvfpQcdSwvTb6PD6ZPJTMri5yWrTnvv/6U7rEbtYpK57on5vP38weRmWE8Oq2Uj1Z+wS+OO5A5pRt4ef4q3liwmiN65fHs5UdSUencNGUB6zdXvUfoTVM+5L4LBmEY85Zv4JF3dv11isbBdj2vqb7ArGuiK7r7p/W5geLe/f139z21F6NJutw4eX66R5A99NEfv/Ouuw/cdX2iPfjT7PwsOrHlfKAAvW2TyH4v0Tu69ItfNrNiqv4Lo28DN0Q6lYgkRX1ei36gmd0LPEvVz8b7uLveVVWkAUj0rqoHA9cCfYGbgfPcXW/0INKAJDoHnwUso+pcfDAw2OJeHOLuo6IdTUT2VaLAz4OaXgImIg1FosAnuPv2lE0iIkmX6Em2aTu+MDM9qSbSACUKPP7n3/rPBkUaoESB6/xbpIFLdA7+NTObTdWe/IDY18SW3d37Rz6diOyTRIH3TtkUIhKJRC9VXZrKQUQk+RK9km0TNZ+H7zhEbxXZVCKSFIn24C1ru0xEGoZ6/eeDItIwKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgClwkYApcJGAKXCRgJm7R3sDZp8DSyO9kfTJA1anewipt5Afr27unr/rysgDD5mZzXD3gemeQ+qnMT5eOkQXCZgCFwmYAt8349M9gOyRRvd46RxcJGDag4sETIGLBEyB18DMvoh9LjazuTVcPsLM5plZpZkNjFt/tpnNjPuoNLOSVM4ekl0eh/Jd/m6zzewnsb/j/nHXmWtmxTX8WUvMLG8PbnuYmR2ejPuRTgp878wFTgNej1/p7g+6e4m7lwA/Apa4+8x0DBigj3f83cY+tsbWlwLXRnB7wwAF3hi5+wfuvqCOzc4CJqVinkZuCtDXzA6qx7ZXmNm02EdPADPLN7PHzGx67GNo7AjgQuDS2NHCkWZ2kpm9Y2bvm9mLZtYhuruUPAo8OmegwJPpgLjD8zvj1lcCNwPX1OPP2Ojug4E7gD/H1o0Dxrr7IOB04K/uvgT4S2x9ibu/AbwJfMPdvw48BFyZlHsVsax0DxAiMzsM2Ozuu52/y177OHbqU5OJwLVm1r2OP2NS3Oexsa+/DfQxsx3btDKzljVctwvwsJkVAtnAJ/WePI0UeDTORHvvlHH37Wb2J+DXdW1aw9cZwBB3L4/fMC74HW4HbnX3f5rZMGD0Xg+cQjpETzIzywBGUHUYJ6lzL1V7491+oyrOGXGf3459/Txw8Y4N4n7qsQmI35O3BpbHvj53H2dNGQVet4PMrDTuY4SZDTezUmAI8LSZPRe3/VFAqbsvTs+4jVPsWfXbgIIEmzU1s3eAXwCXxtaNAgaa2Wwzm0/Vk2sATwHDdzzJRtUee7KZvUED+pVTvVRVJGDag4sETIGLBEyBiwRMgYsETIGLBEyBiwRMgYsE7N/h6n0FXKJ02gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B2', 'B4', 'C5']\n",
      "0.5825825825825826\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B2', 'B5', 'C5']\n",
      "0.6335797254487856\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B4', 'B5', 'C5']\n",
      "0.6195924204504827\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B2', 'B4', 'B5']\n",
      "0.5597609561752988\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B2', 'B4', 'B5', 'C5']\n",
      "0.5195154777927322\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Confusion Matrix ###\n",
    "from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier\n",
    "from sklearn.svm import SVC \n",
    "from sklearn.neighbors import KNeighborsClassifier \n",
    "from sklearn.naive_bayes import GaussianNB \n",
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "#import xgboost\n",
    "\n",
    "def cross_validation(X, Y):\n",
    "    inds = np.arange(len(Y))\n",
    "    np.random.seed(122)\n",
    "    np.random.shuffle(inds)\n",
    "\n",
    "    valid_Ys = []\n",
    "    valid_y_preds = []\n",
    "    for i in range(10):\n",
    "        #print(i)\n",
    "        valid_inds = inds[int(0.1 * len(X) * i):int(0.1 * len(X) * (i+1))]\n",
    "        train_inds = np.array([i for i in inds if not i in valid_inds])\n",
    "        train_X = X[train_inds]\n",
    "        train_Y = Y[train_inds]\n",
    "        valid_X = X[valid_inds]\n",
    "        valid_Y = Y[valid_inds]\n",
    "\n",
    "        model = GradientBoostingClassifier(n_estimators=100)\n",
    "        #model = RandomForestClassifier(n_estimators=100)\n",
    "        #model = SVC(kernel = 'linear', C = 1)\n",
    "        #model = KNeighborsClassifier(n_neighbors = 10)\n",
    "        #model = GaussianNB()\n",
    "        #model = xgboost.XGBClassifier(n_estimators=100)\n",
    "        model.fit(train_X, train_Y)\n",
    "        valid_y_pred = model.predict(valid_X)\n",
    "        valid_Ys.append(valid_Y)\n",
    "        valid_y_preds.append(valid_y_pred)\n",
    "    valid_Ys = np.concatenate(valid_Ys)\n",
    "    valid_y_preds = np.concatenate(valid_y_preds)\n",
    "    return valid_Ys, valid_y_preds\n",
    "\n",
    "t_lag = 1\n",
    "traj_properties = {}\n",
    "\n",
    "well_orders = [['B2', 'C5'],\n",
    "               ['B4', 'C5'],\n",
    "               ['B5', 'C5'],\n",
    "               ['B2', 'B4'],\n",
    "               ['B2', 'B5'],\n",
    "               ['B4', 'B5'],\n",
    "               ['B2', 'B4', 'C5'],\n",
    "               ['B2', 'B5', 'C5'],\n",
    "               ['B4', 'B5', 'C5'],\n",
    "               ['B2', 'B4', 'B5'],\n",
    "               ['B2', 'B4', 'B5', 'C5']]\n",
    "for l, well_order in enumerate(well_orders):\n",
    "    print(well_order)\n",
    "    X = []\n",
    "    state_Y = []\n",
    "    well_Y = []\n",
    "    for i, t in enumerate(t_arrays):\n",
    "        well = t[:2]\n",
    "        if not well in well_order:\n",
    "            continue\n",
    "        X.append(np.concatenate([traj_vector_latent_vector[t], traj_vector_motion[t]]))\n",
    "        state_Y.append(np.argmax(prob_mat[i]))\n",
    "        well_Y.append(well_order.index(well))\n",
    "    X = np.array(X)\n",
    "    X[np.where(X != X)] = 0.\n",
    "    X = X/np.std(X, 0)\n",
    "    state_Y = np.array(state_Y)\n",
    "    well_Y = np.array(well_Y)\n",
    "\n",
    "    valid_Ys, valid_y_preds = cross_validation(X, well_Y)\n",
    "    plt.clf()\n",
    "    f = plt.figure(figsize=(4, 4))\n",
    "    print(accuracy_score(valid_Ys, valid_y_preds))\n",
    "    c_mat = confusion_matrix(valid_Ys, valid_y_preds)\n",
    "    r_mat = c_mat/c_mat.sum(1, keepdims=True)\n",
    "    plt.imshow(r_mat, cmap='Blues', vmin=0., vmax=0.9)\n",
    "    for i, row in enumerate(r_mat):\n",
    "        for j, val in enumerate(row):\n",
    "            c = 'w' if val >= 0.4 else 'k'\n",
    "            #plt.text(j-0.2, i-0.1, str(c_mat[i, j]), color=c)\n",
    "            plt.text(j-0.2, i+0.05, \"%.2f\" % val, color=c)\n",
    "    plt.xticks([i for i in range(len(well_order))], [legends[w] for w in well_order])\n",
    "    plt.yticks([i for i in range(len(well_order))], [legends[w] for w in well_order], rotation='vertical', va='center')\n",
    "    plt.show()\n",
    "    #plt.savefig('conf_mat/Confusion_mat_%d.png' % l, dpi=300)\n",
    "    # plt.xlabel('Predicted labels', fontsize=16)\n",
    "    # plt.ylabel('True labels', fontsize=16)\n",
    "    # plt.savefig('Confusion_mat_well.png', dpi=300)\n",
    "    # plt.savefig('Confusion_mat_well.eps')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=1,\n",
       "            oob_score=False, random_state=None, verbose=0,\n",
       "            warm_start=False)"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = RandomForestClassifier(n_estimators=100)\n",
    "model.fit(X, Y)\n",
    "for i in np.argsort(model.feature_importances_)[-10:]:\n",
    "    print(\"%s\\t\\t%f\" % (feat_name[i], model.feature_importances_[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([], <a list of 0 Text yticklabel objects>)"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAH4AAAB+CAYAAADiI6WIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAJjElEQVR4nO3de1hUZR7A8e8ZhpGLcjHkMoOAiAEqKiBWmC5JQgaJV7TcLCtLSzNaTH18KHNTV901csvdNHc1bc27JuRlNbVsVVAQMk0fL1wcQFBRXFRGxrN/uEs7QSSrM7C+7+cvDucd5neeL3N5eDhzFFVVkcSjae4BpOYhwwtKhheUDC8oGV5QMrygtE1ZrGgdVUXXxlqzNJuw4PbNPYJVFBcVcuniBaWhfU0Lr2tDq+DkezNVC7J194LmHsEqBjz2yM/uk0/1gpLhBSXDC0qGF5QMLygZXlAyvKBkeEHJ8IKS4QUlwwtKhheUDC8oGV5QMrygZHhByfCCkuEFJcMLSoYXVLOE7x8dSt7GNI5ufofUMf3r7ffzcefLP08ka/U0ti+ZhMHTDYBuDxrYs/w3HF43nazV0xgWF2Hr0Ru1e+d2+kR1pXdEKB++P7/e/pqaGsa9MIreEaEkPv4oxUUFANy8eZNJ418kNjqCXz3UjT8umGf1WW0eXqNRSJ+aTNKERYQPfY/hT0QSEuhtsWZOymA+y8yi14g5zF68lZkTBwJw7cZNXkz7lMhhs0iasIh5qUNxbe1o60NokNlsZvrkSaxc+wW7D+Sxaf1qTv5w3GLNqhV/xdXVjW9zjjN2/OvMmjEdgIxN6zHV1LDrHzls232Alcs+qfulsBabh4/qGsDp4gsUGC9ys9bM2u05JMZ0s1gTEujDnoMnANibfZLEmDAAThWVc7qoAoDSiitUVF7Fo21r2x7Az8g9nE1AYEf8AwLR6XQkDUlm+5dbLNbs2LqF4U8/C0BC0hD27d2NqqooisK1a9XU1tZy/cZ17HX2tG7jYtV5bR5e7+nKufOVddvG85UY2rlarPnupJFBsT0ASOrXHZfWjrR1dbZY07OLPzqtljPFF6w/9B0oKy1Bb/jxxAwfvYGyUqPlmpIS9AZfALRaLS4uLlReukhC0hCcnJwJD/GnV1gQ4yak4O7e1qrz2jy8Qv0TO3760QzT3t9In8gg9q+aQp/IIIznK6k1m+v2e3u4sPS90bwyYyUt5YMdGppDUSyPVa13pICicORwNnZ2duQcL+DAkRN8/FE6hQVnrDUq0MQzae4FY/llfL3c67YNXu6UVFyxWFNacYWRqZ8A4OyoY1BsD6r+eQOANs4ObFg4nnc/yiDruwKbzf1LfPQGSozFddulJUa8vPUNrDmH3uBLbW0tVVVVuLu3ZeO6z4mJjcPe3h6Pdp5EPRRNXm4O/gGBVpvX5o/4Q98XEuTXDn/9A9hr7RgeH0HmnnyLNQ+4Odc9Wia/EM/yzQcAsNfasfoPY/lbxkE27My19eiN6hHRk7OnT1FUeBaTycTmDWuIG5BosSbuiUTWrloBQObmDfTuG4OiKBh8/fj2mz2oqsq16mpyDh0kqFOwVee1+SPebL5Fytw1bFn0GnYaheWbD3D8TBlp4xPIOVZE5t7v6NuzEzMnDkRVYV/OKd6YswaAoXERPBoRRFs3Z3498GEAXn57BfknjY3dpU1otVrem5fOM0MTuWU2M2LU8wSHdmb+7Hfp3iOCuCefYuSzY3h93Bh6R4Ti5t6WRUtv/xI8/9I4UiaMpV90OKqqMuKZ0XTuGmbVeZWmvEZqnDzV+/GkydP38UmTebmHGzxbVv7lTlAyvKBkeEHJ8IKS4QUlwwtKhheUDC8oGV5QMrygZHhByfCCkuEFJcMLSoYXlAwvKBleUDK8oGR4QcnwgpLhBSXDC6pJ/1ff5UFfNm6vf/rv/7uO8dObewSrqGnkfAP5iBeUDC8oGV5QMrygZHhByfCCkuEFJcMLSoYXlAwvKBleUDK8oGR4QcnwgpLhBSXDC0qGF5QMLygZXlAyvKBkeEHJ8IJqlvBff7WDuOjuxD7UlY8X/r7e/qz9+0h6/BFC9G3YumVj3fePHc1j+JMxDOgbSWJMLzI3rbPl2L+o/8PB5K2ZzNF1U0gd/Vi9/e293Ni26BX2f/oGWSvfJD46BACtnYYlb48g+7M3yf08ldTn6t/2XmuGz6s3M2NqCsvWZOCtNzA0vg/94hPoFBxat0ZvaM/cDxaz9E8fWNzW0dGJ+R9+QkBgEOfLShjcvzd9HnscF1c3Wx9GPRqNQvrkwSRMXIyx/Ar7lr1Oxjff88PZ8ro1U16IZf3OfJZs2E9IB082LXiRkMFzGBrbjVY6LVGjFuDYyp7cz1NZs+MIRaWVjdzj3bF5+PycQ/h36IhfQAcAEgYNY9e2DIvwvn7+ACgayyekDh071X3t5a3nAQ9PLl280CLCR3X24/S5CxSUXAJg7d+PkNi3i0V4VQUX51YAuDo7Unqh6vb3AScHHXZ2Ghxb2WOqNXO1+oZV57V5+LKyEnz0hrptb72BvJzsJv+cvJxsTDdN+Fnxui1Nofd04dz5y3XbxvIr9OriZ7Fm1pIdbFk4lvHJvXFy0JEwcTEAG3blk9i3C2cz03By0PFW+hdUVl236ry2f41v6GpNDVyZqjHl50uZPOElfpf+MRpNy3h/2uDVtX5yrMlx4azMPETQU7MYnPIXls54GkVRiOrih9l8i8CE3xI6eDaTnulLgP4+u/yYt4+B0pIfz+kqKzHi6e1zx7e/erWKsaOGkDL1HcJ79rLGiP8TY/kVfL1+fMkxeLpS8u+n8v94bmAU63fmAXDwaCEOOi0ebk4kx4ez48AJas23qKisZn9+AZGhvlad1+bhw8IjKThziuLCAkwmE5mb1hEbn3BHtzWZTLz2/EgGDR/FgIFDrDxp0xw6XkxQew/8fdxvX12rfw8yvz5msaa47DIxUbffpwQHeOKg01JRWc25skpiegYB4ORgT6+u/pworLDqvE26GFFYjwh1445v7/pO9+zcxqy0tzCbzQx7ejSvpkwhfe5MwrpHEPtEIvm5h3h1zEiqLl+mlYMDHp5ebP36MJvXrWLqpFcI+q83gnMXLqZz1+53NU/YU2/f7SEBEB8dwvyUgdhpNCzfksW8ZV+R9nIcOcfPkfnNMUI6eLJo2nCcnXSoKkz/MJNdB0/i7KhjcVoyIR28UBSFFRnZvL9y713PU3N0Bbeqyxp8HW2W8C3NvQrf0jQWvmW8M5JsToYXlAwvKBleUDK8oGR4QcnwgpLhBSXDC0qGF5QMLygZXlAyvKBkeEHJ8IKS4QUlwwtKhheUDC8oGV5QMrygZHhByfCCatL/1SuKUgEUWm8c6R7zV1W1XUM7mhReun/Ip3pByfCCkuEFJcMLSoYXlAwvKBleUDK8oGR4Qf0LXkXRTobSBhkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "valid_Ys, valid_y_preds = cross_validation(X, state_Y)\n",
    "f = plt.figure(figsize=(2, 2))\n",
    "c_mat = confusion_matrix(valid_Ys, valid_y_preds)\n",
    "r_mat = c_mat/c_mat.sum(1, keepdims=True)\n",
    "plt.imshow(r_mat, cmap='Blues', vmin=0., vmax=0.9)\n",
    "for i, row in enumerate(r_mat):\n",
    "    for j, val in enumerate(row):\n",
    "        c = 'w' if val >= 0.4 else 'k'\n",
    "        #plt.text(j-0.2, i-0.1, str(c_mat[i, j]), color=c)\n",
    "        plt.text(j-0.2, i+0.05, \"%.2f\" % val, color=c)\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "# plt.xlabel('Predicted labels', fontsize=16)\n",
    "# plt.ylabel('True labels', fontsize=16)\n",
    "# plt.savefig('Confusion_mat_state.png', dpi=300)\n",
    "# plt.savefig('Confusion_mat_state.eps')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = plt.figure(figsize=(3, 3))\n",
    "mat = plt.imshow(r_mat, cmap='Blues', vmin=0., vmax=0.9)\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "cbar = f.colorbar(mat, extend='max')\n",
    "plt.savefig('Confusion_mat_cbar.eps')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Histogram of well orientations - patch level ###\n",
    "all_PC2 = np.concatenate([traj_PC2[w] for w in sorted(wells_)])\n",
    "all_speed = np.concatenate([traj_speed[w] for w in sorted(wells_)])\n",
    "speed_ticks = [4, 8, 16, 32, 64, 128]\n",
    "for i_w, well in enumerate(sorted(wells_)):\n",
    "    plt.clf()\n",
    "    f = plt.figure(figsize=(4, 3))\n",
    "    plt.plot(all_PC2, \n",
    "             all_speed, \n",
    "             '.', \n",
    "             c=(0.8, 0.8, 0.8), \n",
    "             markeredgecolor='none', \n",
    "             markersize=2.)\n",
    "    df = {'PC2': np.array(traj_PC2[well]),\n",
    "          'Speed': np.array(traj_speed[well]),\n",
    "          'State': traj_states[well]}\n",
    "    inds = [i for i, s in enumerate(df['State']) if s[0] > s[1]]\n",
    "    plt.plot(df['PC2'][inds],\n",
    "             df['Speed'][inds],\n",
    "             '.',\n",
    "             c=state_cmaps[0](0.8),\n",
    "             markeredgecolor='none', \n",
    "             markersize=3.)\n",
    "    inds = [i for i, s in enumerate(df['State']) if s[1] > s[0]]\n",
    "    plt.plot(df['PC2'][inds],\n",
    "             df['Speed'][inds],\n",
    "             '.',\n",
    "             c=state_cmaps[1](0.8),\n",
    "             markeredgecolor='none', \n",
    "             markersize=3.)\n",
    "    plt.gca().set_yticks(np.log(speed_ticks))\n",
    "    plt.gca().set_yticklabels(speed_ticks)\n",
    "    plt.savefig('NOVEMBER_clustering_%s.eps' % well)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.stack(df['State']).sum(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Supp Fig 5\n",
    "JUNE_data_dir =  '/gpfs/CompMicro/Projects/learningCellState/microglia/data_processed'\n",
    "JUNE_trajs = pickle.load(open(os.path.join(JUNE_data_dir, 'D_trajectories.pkl'), 'rb'))\n",
    "JUNE_dats = pickle.load(open(os.path.join(JUNE_data_dir, 'D_latent_space_PCAed.pkl'), 'rb'))\n",
    "\n",
    "JUNE_traj_PC1_diffs = []\n",
    "JUNE_traj_PC2_diffs = []\n",
    "JUNE_base_PC1_diffs = []\n",
    "JUNE_base_PC2_diffs = []\n",
    "\n",
    "for t in JUNE_trajs:\n",
    "    traj_PC1 = JUNE_dats[np.array(JUNE_trajs[t])][:, 0]\n",
    "    traj_PC2 = JUNE_dats[np.array(JUNE_trajs[t])][:, 1]\n",
    "    traj_PC1_diff = np.abs(traj_PC1[1:] - traj_PC1[:-1])\n",
    "    traj_PC2_diff = np.abs(traj_PC2[1:] - traj_PC2[:-1])\n",
    "    JUNE_traj_PC1_diffs.append(traj_PC1_diff)\n",
    "    JUNE_traj_PC2_diffs.append(traj_PC2_diff)\n",
    "    random_PC1 = JUNE_dats[np.random.choice(np.arange(JUNE_dats.shape[0]), \n",
    "                                            (len(JUNE_trajs[t]),), \n",
    "                                            replace=False), 0]\n",
    "    random_PC2 = JUNE_dats[np.random.choice(np.arange(JUNE_dats.shape[0]), \n",
    "                                            (len(JUNE_trajs[t]),), \n",
    "                                            replace=False), 1]\n",
    "    JUNE_base_PC1_diffs.append(np.abs(random_PC1[1:] - random_PC1[:-1]))\n",
    "    JUNE_base_PC2_diffs.append(np.abs(random_PC2[1:] - random_PC2[:-1]))\n",
    "JUNE_traj_PC1_diffs = np.concatenate(JUNE_traj_PC1_diffs)\n",
    "JUNE_traj_PC2_diffs = np.concatenate(JUNE_traj_PC2_diffs)\n",
    "JUNE_base_PC1_diffs = np.concatenate(JUNE_base_PC1_diffs)\n",
    "JUNE_base_PC2_diffs = np.concatenate(JUNE_base_PC2_diffs)\n",
    "\n",
    "NOVEMBER_traj_PC1_diffs = []\n",
    "NOVEMBER_traj_PC2_diffs = []\n",
    "NOVEMBER_base_PC1_diffs = []\n",
    "NOVEMBER_base_PC2_diffs = []\n",
    "for t in traj_inds:\n",
    "    well = t[:2]\n",
    "    traj_PC1 = dats[well][np.array(traj_inds[t])][:, 0]\n",
    "    traj_PC2 = dats[well][np.array(traj_inds[t])][:, 1]\n",
    "    traj_PC1_diff = np.abs(traj_PC1[1:] - traj_PC1[:-1])\n",
    "    traj_PC2_diff = np.abs(traj_PC2[1:] - traj_PC2[:-1])\n",
    "    NOVEMBER_traj_PC1_diffs.append(traj_PC1_diff)\n",
    "    NOVEMBER_traj_PC2_diffs.append(traj_PC2_diff)\n",
    "    random_PC1 = dats[well][np.random.choice(np.arange(dats[well].shape[0]), \n",
    "                                             (len(traj_inds[t]),), \n",
    "                                             replace=False), 0]\n",
    "    random_PC2 = dats[well][np.random.choice(np.arange(dats[well].shape[0]), \n",
    "                                             (len(traj_inds[t]),), \n",
    "                                             replace=False), 1]\n",
    "    NOVEMBER_base_PC1_diffs.append(np.abs(random_PC1[1:] - random_PC1[:-1]))\n",
    "    NOVEMBER_base_PC2_diffs.append(np.abs(random_PC2[1:] - random_PC2[:-1]))\n",
    "NOVEMBER_traj_PC1_diffs = np.concatenate(NOVEMBER_traj_PC1_diffs)\n",
    "NOVEMBER_traj_PC2_diffs = np.concatenate(NOVEMBER_traj_PC2_diffs)\n",
    "NOVEMBER_base_PC1_diffs = np.concatenate(NOVEMBER_base_PC1_diffs)\n",
    "NOVEMBER_base_PC2_diffs = np.concatenate(NOVEMBER_base_PC2_diffs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "line_JUNE = np.histogram(JUNE_traj_PC1_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "line_NOVEMBER = np.histogram(NOVEMBER_traj_PC1_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "line_base_JUNE = np.histogram(JUNE_base_PC1_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "line_base_NOVEMBER = np.histogram(NOVEMBER_base_PC1_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "\n",
    "plt.clf()\n",
    "plt.bar(line_JUNE[1][:-1]+0.1-0.06, line_JUNE[0], width=0.06, color=matplotlib.cm.get_cmap('Blues')(0.6), label='Train Set Trajectories')\n",
    "plt.bar(line_JUNE[1][:-1]+0.1+0.00, line_base_JUNE[0], width=0.06, color=matplotlib.cm.get_cmap('Greys')(0.5), label='Random Baseline')\n",
    "plt.legend(fontsize=16)\n",
    "plt.xlabel('PC1 diff', fontsize=16)\n",
    "plt.ylabel('Frequency', fontsize=16)\n",
    "plt.savefig(\"figS5_JUNE_PC1.eps\")\n",
    "\n",
    "plt.clf()\n",
    "plt.bar(line_JUNE[1][:-1]+0.1-0.06, line_NOVEMBER[0], width=0.06, color=matplotlib.cm.get_cmap('Reds')(0.6), label='Test Set Trajectories')\n",
    "plt.bar(line_JUNE[1][:-1]+0.1+0.00, line_base_NOVEMBER[0], width=0.06, color=matplotlib.cm.get_cmap('Greys')(0.5), label='Random Baseline')\n",
    "plt.legend(fontsize=16)\n",
    "plt.xlabel('PC1 diff', fontsize=16)\n",
    "plt.ylabel('Frequency', fontsize=16)\n",
    "plt.savefig(\"figS5_NOVEMBER_PC1.eps\")\n",
    "\n",
    "\n",
    "line_JUNE = np.histogram(JUNE_traj_PC2_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "line_NOVEMBER = np.histogram(NOVEMBER_traj_PC2_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "line_base_JUNE = np.histogram(JUNE_base_PC2_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "line_base_NOVEMBER = np.histogram(NOVEMBER_base_PC2_diffs, bins=np.arange(0, 8, 0.2), density=True)\n",
    "\n",
    "plt.clf()\n",
    "plt.bar(line_JUNE[1][:-1]+0.1-0.06, line_JUNE[0], width=0.06, color=matplotlib.cm.get_cmap('Blues')(0.6), label='Train Set Trajectories')\n",
    "plt.bar(line_JUNE[1][:-1]+0.1+0.00, line_base_JUNE[0], width=0.06, color=matplotlib.cm.get_cmap('Greys')(0.5), label='Random Baseline')\n",
    "plt.legend(fontsize=16)\n",
    "plt.xlabel('PC2 diff', fontsize=16)\n",
    "plt.ylabel('Frequency', fontsize=16)\n",
    "plt.savefig(\"figS5_JUNE_PC2.eps\")\n",
    "\n",
    "plt.clf()\n",
    "plt.bar(line_JUNE[1][:-1]+0.1-0.06, line_NOVEMBER[0], width=0.06, color=matplotlib.cm.get_cmap('Reds')(0.6), label='Test Set Trajectories')\n",
    "plt.bar(line_JUNE[1][:-1]+0.1+0.00, line_base_NOVEMBER[0], width=0.06, color=matplotlib.cm.get_cmap('Greys')(0.5), label='Random Baseline')\n",
    "plt.legend(fontsize=16)\n",
    "plt.xlabel('PC2 diff', fontsize=16)\n",
    "plt.ylabel('Frequency', fontsize=16)\n",
    "plt.savefig(\"figS5_NOVEMBER_PC2.eps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Supp Fig 2\n",
    "# Scatter plot between PC1 and size\n",
    "sizes = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_sizes.pkl'), 'rb'))\n",
    "densities = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_intensities.pkl'), 'rb'))\n",
    "\n",
    "all_fs = sum([fs[w] for w in wells], [])\n",
    "ss = np.log(np.array([sizes[f] for f in all_fs]))\n",
    "ds = np.array([densities[f][0][2] for f in all_fs])\n",
    "\n",
    "df = {'PC1': np.concatenate([patch_PC1[w] for w in wells]),\n",
    "      'PC2': np.concatenate([patch_PC2[w] for w in wells]),\n",
    "      'Size': ss,\n",
    "      'Peak Phase': ds}\n",
    "\n",
    "from scipy.stats import spearmanr\n",
    "print(spearmanr(df['Peak Phase'], df['PC2']))\n",
    "print(spearmanr(df['Size'], df['PC1']))\n",
    "print(spearmanr(df['Size'], df['PC2']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "sns.set_style('white')\n",
    "bins_y = np.linspace(6, 9.3, 20)\n",
    "bins_x = np.linspace(-6, 6, 20)\n",
    "plt.clf()\n",
    "g = sns.JointGrid(x='PC1', y='Size', data=df, ylim=(6, 9.3), xlim=(-6, 6))\n",
    "_ = g.ax_marg_x.hist(df['PC1'], bins=bins_x, color=matplotlib.cm.get_cmap('Blues')(0.5))\n",
    "_ = g.ax_marg_y.hist(df['Size'], bins=bins_y, orientation='horizontal', color=matplotlib.cm.get_cmap('Blues')(0.5))\n",
    "g.plot_joint(plt.hexbin, cmap=\"Blues\")\n",
    "y_ticks = np.array([500, 1000, 2000, 4000, 8000])\n",
    "g.ax_joint.set_yticks(np.log(y_ticks))\n",
    "g.ax_joint.set_yticklabels(y_ticks)\n",
    "g.set_axis_labels('PC1', 'Size', fontsize=16)\n",
    "plt.tight_layout()\n",
    "plt.savefig('NOVEMBER_joint_density_PC1_size.eps')\n",
    "#plt.savefig('/home/michaelwu/figs/supp_fig2_PC1_size.png', dpi=300)\n",
    "\n",
    "sns.set_style('white')\n",
    "bins_y = np.linspace(0.52, 0.8, 20)\n",
    "bins_x = np.linspace(-3, 8, 20)\n",
    "plt.clf()\n",
    "g = sns.JointGrid(x='PC2', y='Peak Phase', data=df, ylim=(0.52, 0.8), xlim=(-3, 8))\n",
    "_ = g.ax_marg_x.hist(df['PC2'], bins=bins_x, color=matplotlib.cm.get_cmap('Reds')(0.5))\n",
    "_ = g.ax_marg_y.hist(df['Peak Phase'], bins=bins_y, orientation='horizontal', color=matplotlib.cm.get_cmap('Reds')(0.5))\n",
    "g.plot_joint(plt.hexbin, cmap=\"Reds\")\n",
    "g.set_axis_labels('PC2', 'Peak Phase', fontsize=16)\n",
    "plt.tight_layout()\n",
    "plt.savefig('NOVEMBER_joint_density_PC2_density.eps')\n",
    "# plt.savefig('/home/michaelwu/figs/supp_fig2_PC2_density.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Supp Fig 4\n",
    "from scipy.stats import spearmanr, pearsonr\n",
    "sizes = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_sizes.pkl'), 'rb'))\n",
    "densities = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_intensities.pkl'), 'rb'))\n",
    "aps_nr = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_aspect_ratios_nr.pkl'), 'rb'))\n",
    "aps = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_aspect_ratios.pkl'), 'rb'))\n",
    "\n",
    "PCs = [np.concatenate([dats[well][:, i] for well in sorted(wells_)]) for i in range(6)]\n",
    "all_fs = sum([fs[w] for w in sorted(wells_)], [])\n",
    "Properties = [[np.log(sizes[f]) for f in all_fs],\n",
    "              [densities[f][0][2] for f in all_fs],\n",
    "              [densities[f][1][2] for f in all_fs],\n",
    "              [aps_nr[f][0]/aps_nr[f][1] for f in all_fs],\n",
    "              [aps[f][1] if aps[f][1] > 0 else aps[f][1] + np.pi for f in all_fs]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sr_mat = np.zeros((len(PCs), len(Properties)))\n",
    "pr_mat = np.zeros((len(PCs), len(Properties)))\n",
    "for i, PC in enumerate(PCs):\n",
    "  for j, prop in enumerate(Properties):\n",
    "    sr_mat[i, j] = spearmanr(PC, prop).correlation\n",
    "    pr_mat[i, j] = pearsonr(PC, prop)[0]\n",
    "\n",
    "plt.clf()\n",
    "fig, ax = plt.subplots()\n",
    "cmap = matplotlib.cm.get_cmap('RdBu')\n",
    "im = ax.imshow(np.transpose(sr_mat), cmap=cmap, vmin=-1.5, vmax=1.5)\n",
    "\n",
    "ax.set_xticks(np.arange(len(PCs)))\n",
    "ax.set_yticks(np.arange(len(Properties)))\n",
    "ax.set_xticklabels(['PC1', 'PC2', 'PC3', 'PC4', 'PC5', 'PC6'])\n",
    "ax.set_yticklabels(['Size', 'Peak Phase', 'Peak Retardance', 'Aspect Ratio', 'Angle (Long axis)'])\n",
    "for i in range(len(PCs)):\n",
    "  for j in range(len(Properties)):\n",
    "    text = ax.text(i, j, \"%.2f\" % sr_mat[i, j], ha=\"center\", va=\"center\", color=\"k\")\n",
    "plt.tight_layout()\n",
    "# plt.show()\n",
    "plt.savefig('NOVEMBER_correlations.eps')\n",
    "plt.savefig('NOVEMBER_correlations.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Supp Fig 7\n",
    "JUNE_data_dir =  '/gpfs/CompMicro/Projects/learningCellState/microglia/data_processed'\n",
    "JUNE_dats = pickle.load(open(os.path.join(JUNE_data_dir, 'D_latent_space_PCAed.pkl'), 'rb'))\n",
    "JUNE_fs = sorted(pickle.load(open(os.path.join(JUNE_data_dir, 'D_file_paths.pkl'), 'rb')))\n",
    "JUNE_sizes = pickle.load(open('/gpfs/CompMicro/Projects/CellVAE/Data/EncodedSizes.pkl', 'rb'))\n",
    "ss = [JUNE_sizes[f][0] for f in JUNE_fs]\n",
    "cmap = matplotlib.cm.get_cmap('BuPu')  \n",
    "range_min = np.log(min(ss))\n",
    "range_max = np.log(max(ss))\n",
    "JUNE_colors = [cmap(((np.log(s) - range_min)/(range_max - range_min))**1.5) for s in ss]\n",
    "\n",
    "NOVEMBER_dats = np.concatenate([dats[w] for w in sorted(wells_)])\n",
    "NOVEMBER_fs = np.concatenate([fs[w] for w in sorted(wells_)])\n",
    "NOVEMBER_sizes = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_sizes.pkl'), 'rb'))\n",
    "ss = [NOVEMBER_sizes[f] for f in NOVEMBER_fs]\n",
    "NOVEMBER_colors = [cmap(((np.log(s) - range_min)/(range_max - range_min))**1.5) for s in ss]\n",
    "\n",
    "with open('temp_save.pkl', 'wb') as f:\n",
    "    pickle.dump([JUNE_dats, JUNE_colors, NOVEMBER_dats, NOVEMBER_colors], f)\n",
    "    \n",
    "# Below need to be run on x86 linux\n",
    "import umap\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "JUNE_dats, JUNE_colors, NOVEMBER_dats, NOVEMBER_colors = pickle.load(open('temp_save.pkl', 'rb'))\n",
    "reducer = umap.UMAP()\n",
    "JUNE_embedding = reducer.fit_transform(JUNE_dats)\n",
    "NOVEMBER_embedding = reducer.transform(NOVEMBER_dats)\n",
    "plt.clf()\n",
    "plt.scatter(JUNE_embedding[:, 0], JUNE_embedding[:, 1], c=JUNE_colors, s=0.5, edgecolors='none')\n",
    "plt.xlim(-6, 7)\n",
    "plt.ylim(-7, 7.5)\n",
    "plt.savefig('JUNE_UMAP.eps')\n",
    "plt.savefig('JUNE_UMAP.png', dpi=300)\n",
    "plt.clf()\n",
    "plt.scatter(NOVEMBER_embedding[:, 0], NOVEMBER_embedding[:, 1], c=NOVEMBER_colors, s=0.5, edgecolors='none')\n",
    "plt.xlim(-6, 7)\n",
    "plt.ylim(-7, 7.5)\n",
    "plt.savefig('NOVEMBER_UMAP.eps')\n",
    "plt.savefig('NOVEMBER_UMAP.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NOVEMBER_dats = np.concatenate([dats[w] for w in sorted(wells_)])\n",
    "NOVEMBER_fs = np.concatenate([fs[w] for w in sorted(wells_)])\n",
    "NOVEMBER_sizes = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_sizes.pkl'), 'rb'))\n",
    "ss = [NOVEMBER_sizes[f] for f in NOVEMBER_fs]\n",
    "cmap = matplotlib.cm.get_cmap('BuPu')\n",
    "range_min = np.log(min(ss))\n",
    "range_max = np.log(max(ss))\n",
    "NOVEMBER_colors = [cmap(((np.log(s) - range_min)/(range_max - range_min))**1.5) for s in ss]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import umap\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "#reducer = umap.UMAP()\n",
    "#NOVEMBER_embedding = reducer.fit_transform(NOVEMBER_dats)\n",
    "plt.clf()\n",
    "plt.scatter(NOVEMBER_embedding[:, 0], NOVEMBER_embedding[:, 1], c=NOVEMBER_colors, s=0.5, edgecolors='none')\n",
    "plt.show()\n",
    "#plt.xlim(-6, 7)\n",
    "#plt.ylim(-7, 7.5)\n",
    "#plt.savefig('NOVEMBER_UMAP.eps')\n",
    "#plt.savefig('NOVEMBER_UMAP.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extra data on test set reconstruction error\n",
    "model = VQ_VAE(alpha=0.0005, gpu=True)\n",
    "model = model.cuda()\n",
    "model.load_state_dict(torch.load('HiddenStateExtractor/save_0005_bkp4.pt'))\n",
    "\n",
    "test_r_losses = []\n",
    "for k in np.random.choice(list(all_patches.keys()), (5000,), replace=False):\n",
    "  sample = all_patches[k]\n",
    "  sample = sample.cuda()\n",
    "  output, loss = model.forward(sample)\n",
    "  r_loss = loss['recon_loss']\n",
    "  test_r_losses.append(r_loss.data.cpu().numpy())\n",
    "\n",
    "print(np.mean(test_r_losses))\n",
    "print(np.std(test_r_losses))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save trajectory videos\n",
    "traj_samples = ['B2-Site_0/35',\n",
    "                'C4-Site_2/189',\n",
    "                'B2-Site_5/21',\n",
    "                'C4-Site_2/3']\n",
    "\n",
    "for t in traj_samples:\n",
    "    save_traj_bbox(t, 'supp_video_PCA_test_sample_bbox_%s.gif' % t.replace('/', '_'))\n",
    "    save_movie(t, 'supp_video_PCA_test_sample_movie_%s.gif' % t.replace('/', '_'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts_of_I = [\n",
    "    'B2-Site_0/11', 'B2-Site_0/35', 'B2-Site_0/40', 'B2-Site_0/45', 'B2-Site_0/48', 'B2-Site_0/221',\n",
    "    'B2-Site_1/74', 'B2-Site_2/9', 'B2-Site_5/35', 'B2-Site_5/125',\n",
    "    'B4-Site_0/67', 'B4-Site_6/65',\n",
    "    'B5-Site_7/3',\n",
    "    'C4-Site_0/49', 'C4-Site_0/77', 'C4-Site_2/51', 'C4-Site_2/52', 'C4-Site_2/53', 'C4-Site_2/59',\n",
    "    'C4-Site_2/149', 'C4-Site_2/189', 'C4-Site_3/109', 'C5-Site_3/22'\n",
    "]\n",
    "\n",
    "X = []\n",
    "Y = []\n",
    "names = []\n",
    "t_lag = 1\n",
    "len_segment = 15\n",
    "for t in ts_of_I:\n",
    "    well = t[:2]\n",
    "    if not well in wells_:\n",
    "        continue\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    dists = []\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            dists.append(d)\n",
    "    traj_PC = [dats[well][ind] for ind in traj_inds[t]]\n",
    "    traj_dist = dists\n",
    "    \n",
    "    if len(traj_inds[t]) > 3*len_segment:\n",
    "        n_segment = len(traj_inds[t]) // len_segment\n",
    "        for i in range(n_segment):\n",
    "            x = np.concatenate([\n",
    "                np.array(np.log(np.mean(traj_dist[i*len_segment:(i+1)*len_segment]) * 0.325 / 0.1518)).reshape((-1,)),\n",
    "                np.mean(traj_PC[i*len_segment:(i+1)*len_segment], 0)])\n",
    "            y = sorted(wells_).index(well)\n",
    "            X.append(x)\n",
    "            Y.append(y)\n",
    "            names.append('%s_segment_%d' % (t, i))\n",
    "\n",
    "X = np.array(X)\n",
    "Y = np.array(Y)\n",
    "stds = [0.85*std_unit for c in centers]\n",
    "prob_mat = get_merged_prob_mat(X, Y, centers, stds, well_prob_mat)\n",
    "\n",
    "d = {}\n",
    "for n, state in zip(names, np.argmax(prob_mat, 1)):\n",
    "    t = '_'.join(n.split('_')[:2])\n",
    "    if not t in d:\n",
    "        d[t] = []\n",
    "    d[t].append(state)\n",
    "\n",
    "ts_plotted = [t for t in d if len(set(d[t])) > 1]\n",
    "for t in ts_plotted:\n",
    "    save_traj_bbox(t, 'supp_video_state_transition_bbox_%s.gif' % t.replace('/', '_'))\n",
    "    save_movie(t, 'supp_video_state_transition_movie_%s.gif' % t.replace('/', '_'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts_of_I = [t for t in trajs if t.startswith('B2')]\n",
    "\n",
    "X = []\n",
    "Y = []\n",
    "names = []\n",
    "t_lag = 1\n",
    "len_segment = 15\n",
    "for t in ts_of_I:\n",
    "    well = t[:2]\n",
    "    if not well in wells_:\n",
    "        continue\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    dists = []\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            dists.append(d)\n",
    "    traj_PC = [dats[well][ind] for ind in traj_inds[t]]\n",
    "    traj_dist = dists\n",
    "    \n",
    "    if len(traj_inds[t]) > 3*len_segment:\n",
    "        n_segment = len(traj_inds[t]) // len_segment\n",
    "        for i in range(n_segment):\n",
    "            x = np.concatenate([\n",
    "                np.array(np.log(np.mean(traj_dist[i*len_segment:(i+1)*len_segment]) * 0.325 / 0.1518)).reshape((-1,)),\n",
    "                np.mean(traj_PC[i*len_segment:(i+1)*len_segment], 0)])\n",
    "            y = sorted(wells_).index(well)\n",
    "            X.append(x)\n",
    "            Y.append(y)\n",
    "            names.append('%s_segment_%d' % (t, i))\n",
    "\n",
    "X = np.array(X)\n",
    "Y = np.array(Y)\n",
    "stds = [0.85*std_unit for c in centers]\n",
    "prob_mat = get_merged_prob_mat(X, Y, centers, stds, well_prob_mat)\n",
    "\n",
    "d = {}\n",
    "for n, state in zip(names, np.argmax(prob_mat, 1)):\n",
    "    t = '_'.join(n.split('_')[:2])\n",
    "    if not t in d:\n",
    "        d[t] = []\n",
    "    d[t].append(state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "39"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts_plotted = {t: d[t] for t in d if len(set(d[t])) > 1}\n",
    "ts_plotted = {t: d[t] for t in ts_plotted if d[t][0] == 1 and d[t][-1] == 0}\n",
    "len(ts_plotted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in ts_plotted:\n",
    "    save_traj_bbox(t, 'supp_video_state_transition_bbox_%s.gif' % t.replace('/', '_'))\n",
    "    save_movie(t, 'supp_video_state_transition_movie_%s.gif' % t.replace('/', '_'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "source": [],
    "metadata": {
     "collapsed": false
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}