FigS3-counterexample-Chignolin.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "from tqdm.notebook import tqdm\n",
    "import networkx as nx\n",
    "import pyemma\n",
    "import mdtraj\n",
    "import pyemma.util.contexts\n",
    "import pickle\n",
    "from pathos.multiprocessing import Pool\n",
    "from contextlib import closing\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "topfile = '/group/ag_cmb/simulation-data/DESRES-Science2011-FastProteinFolding/DESRES-Trajectory_CLN025-0-protein/CLN025-0-protein/folded.pdb'\n",
    "\n",
    "ref = mdtraj.load_pdb(topfile)\n",
    "\n",
    "_dir = '/group/ag_cmb/simulation-data/DESRES-Science2011-FastProteinFolding/DESRES-Trajectory_CLN025-0-protein/CLN025-0-protein/'\n",
    "\n",
    "# ATTENTION: desres is a single fragmented trajectory. pyemma will concatenate with nested loop\n",
    "trajfiles = [[_dir + 'CLN025-0-protein-{:03d}.dcd'.format(n) for n in range(54)]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_resid = 1  # truncate n and c-terminal residues\n",
    "system_integers = np.arange(first_resid, ref.top.n_residues - first_resid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d6f4b4c12d0a48c0b756c4bdb9b8a2ec",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/8 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/storage/mi/thempel/anaconda3/envs/py37_feb21/lib/python3.8/site-packages/mdtraj/geometry/dihedral.py:374: FutureWarning: arrays to stack must be passed as a \"sequence\" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.\n",
      "  indices = np.vstack(x for x in indices if x.size)[id_sort]\n",
      "/storage/mi/thempel/anaconda3/envs/py37_feb21/lib/python3.8/site-packages/pyemma/coordinates/data/featurization/angles.py:211: FutureWarning: arrays to stack must be passed as a \"sequence\" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.\n",
      "  indices = np.vstack(valid.values())\n"
     ]
    }
   ],
   "source": [
    "res_torsions = dict()\n",
    "\n",
    "with pyemma.util.contexts.settings(show_progress_bars=False):\n",
    "    for n in tqdm(system_integers):\n",
    "        f = pyemma.coordinates.featurizer(topfile)\n",
    "\n",
    "        f.add_backbone_torsions(selstr=f'resid {n}', cossin=True)\n",
    "        try:\n",
    "            f.add_sidechain_torsions(selstr=f'resid {n}', cossin=True)\n",
    "        except ValueError:\n",
    "            pass\n",
    "        # make sure it's a list again...\n",
    "        res_torsions[n] = [pyemma.coordinates.load(trajfiles, features=f, stride=5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# choose lag time for vamp computation (in ns)\n",
    "msmlag = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all pairwise combinations of residue indices\n",
    "args = list(itertools.combinations(system_integers, 2))\n",
    "\n",
    "def get_edge_vamp2(n1, n2, stride=1):\n",
    "    \"\"\"\n",
    "    Compute normalized dependency between two feature\n",
    "    vectors using the VAMP2 score.\n",
    "    \n",
    "    :params:\n",
    "    :n1: int, residue index of residue A\n",
    "    :n2: int, residue index of residue B\n",
    "    :stride: int, optional, used in covariance matrix estimation\n",
    "    \n",
    "    :returns:\n",
    "    float, dependency for this link\n",
    "    \"\"\"\n",
    "    with pyemma.util.contexts.settings(show_progress_bars=False):\n",
    "        v1 = pyemma.coordinates.vamp(feature[n1], lag=msmlag, stride=stride)\n",
    "        v2 = pyemma.coordinates.vamp(feature[n2], lag=msmlag, stride=stride)\n",
    "        v12 = pyemma.coordinates.vamp([np.hstack([t1, t2]) for t1, t2 in zip(feature[n1], feature[n2])], lag=msmlag, stride=stride)\n",
    "\n",
    "    s1 = v1.score(score_method='VAMP2')\n",
    "    s2 = v2.score(score_method='VAMP2')\n",
    "    s12 = v12.score(score_method='VAMP2')\n",
    "    \n",
    "    # note that pyemma returns the vamp score in the non-whitened space (+1)\n",
    "    # i.e. we have to subtract 1 from each computed score\n",
    "    d =  (s1 + s2 - 1 - s12) / min(s1 - 1, s2 - 1)\n",
    "        \n",
    "    return d\n",
    "\n",
    "def get_edge_vamp1(n1, n2, stride=1):\n",
    "    \"\"\"\n",
    "    Compute normalized dependency between two feature\n",
    "    vectors using the VAMP1 score.\n",
    "    \n",
    "    :params:\n",
    "    :n1: int, residue index of residue A\n",
    "    :n2: int, residue index of residue B\n",
    "    :stride: int, optional, used in covariance matrix estimation\n",
    "    \n",
    "    :returns:\n",
    "    float, dependency for this link\n",
    "    \"\"\"\n",
    "    with pyemma.util.contexts.settings(show_progress_bars=False):\n",
    "        v1 = pyemma.coordinates.vamp(feature[n1], lag=msmlag, stride=stride)\n",
    "        v2 = pyemma.coordinates.vamp(feature[n2], lag=msmlag, stride=stride)\n",
    "        v12 = pyemma.coordinates.vamp([np.hstack([t1, t2]) for t1, t2 in zip(feature[n1], feature[n2])], lag=msmlag, stride=stride)\n",
    "\n",
    "        s1 = v1.score(score_method='VAMP1')\n",
    "        s2 = v2.score(score_method='VAMP1')\n",
    "        s12 = v12.score(score_method='VAMP1')\n",
    "        \n",
    "        d =  (s1 + s2 - 1 - s12) / min(s1 - 1, s2 - 1)\n",
    "        \n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature = res_torsions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "859915fd18db439ba2cf41c5652f25bf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/28 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VAMP-1 graph\n",
    "# initialize networkx graph object\n",
    "graph_vamp1 = nx.Graph()\n",
    "\n",
    "\n",
    "# multiprocessing w/ progress bar\n",
    "pbar = tqdm(total=len(args))\n",
    "pool = Pool(processes=8)\n",
    "with closing(pool):\n",
    "    # compute pairwise dependency on each pair of residues, populate graph edges\n",
    "    res_async = [pool.apply_async(get_edge_vamp1, a, callback=lambda _: pbar.update(1)) for a in args]\n",
    "    [graph_vamp1.add_edge(*a, weight=x.get()) for x, a in zip(res_async, args)]\n",
    "    \n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c34cd135220b4241961c9c637837ec92",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/28 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VAMP-2 graph\n",
    "# initialize networkx graph object\n",
    "graph_vamp2 = nx.Graph()\n",
    "\n",
    "# multiprocessing w/ progress bar\n",
    "pbar = tqdm(total=len(args))\n",
    "pool = Pool(processes=8)\n",
    "with closing(pool):\n",
    "    # compute pairwise dependency on each pair of residues, populate graph edges\n",
    "    res_async = [pool.apply_async(get_edge_vamp2, a, callback=lambda _: pbar.update(1)) for a in args]\n",
    "    [graph_vamp2.add_edge(*a, weight=x.get()) for x, a in zip(res_async, args)]\n",
    "    \n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set node sizes and edge widths\n",
    "nodesize = 20\n",
    "edgewidth = 1\n",
    "\n",
    "# define color for edges\n",
    "_c = (0., 0., 0.)\n",
    "edge_cmap = plt.matplotlib.colors.LinearSegmentedColormap.from_list(\"uwe\", [(*_c, 0), (*_c, 0),\n",
    "                                                                            (*_c, 0.5), (*_c, 1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fruchterman-Reingold (FR) node positioning\n",
    "# please note that FR is stochastic and results might be slightly different\n",
    "# for each execution\n",
    "\n",
    "ks = [.01, 0.012] # FR hyperparameter\n",
    "\n",
    "pos_dicts = []\n",
    "frugold_projections = []\n",
    "for n, graph in enumerate([graph_vamp1, graph_vamp2]):\n",
    "\n",
    "    # use networkx implementation of FR algorithm\n",
    "    pos_dict = nx.spring_layout(graph, k=ks[n], \n",
    "                                iterations=5000, threshold=0.00001)\n",
    "    pos_dicts.append(pos_dict)\n",
    "    frugold_projections.append(np.array([pos_dict[r] for r in system_integers]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# color definitions\n",
    "sns_pal = sns.color_palette('hls', 4)\n",
    "vmd_colors = np.array(sns_pal)\n",
    "col_pal = ['#80aee7ff', '#e68082ff']  # for histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "initialize kmeans++ centers:   0%|          | 0/4 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "kmeans iterations:   0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "kmeans iterations:   0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# cluster FR projected data with k-means\n",
    "# remember that k-means is stochastic and might produce slightly different \n",
    "# results each for each run. this step further depends on the result of\n",
    "# the FR algorithm, i.e., it might be necessary to adjust hyperparameters\n",
    "\n",
    "# chignolin: no clusters visible\n",
    "n_clusters = [4, 1] # number of nodes for vamp-1 / vamp-2 projections\n",
    "\n",
    "assignments = []\n",
    "cluster_objs = []\n",
    "\n",
    "for n, (k, xy) in enumerate(zip(n_clusters, frugold_projections)):\n",
    "    # cluster in projected space\n",
    "    cl = pyemma.coordinates.cluster_kmeans(xy, k=k, tolerance=1e-7, \n",
    "                                           max_iter=100)\n",
    "    cluster_objs.append(cl)\n",
    "    assignments.append(cl.dtrajs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "matched_assignments = assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to quantify the differences between a) dependencies of\n",
    "# nodes in a cluster and b) dependencies between nodes of different clusters, \n",
    "# each node has to be viewed from its strongest embedding into the network. \n",
    "# \n",
    "# Example: network consisting of 3 nodes [n1, n2, n3]. If dependency scores \n",
    "# between (n1, n2) and (n2, n3) are very high, the network cannot be decomposed\n",
    "# irrespectively of how low the dependency is for (n1, n3).\n",
    "    \n",
    "# This means that the dependency between a single node n and a set of nodes C\n",
    "# should be viewed by taking the max of all edges between n and all nodes of C. \n",
    "\n",
    "intra_cluster_edge_list, inter_cluster_edge_list = [], []\n",
    "for assignments, graph, _n_clusters in zip(matched_assignments, \n",
    "                                           [graph_vamp1, graph_vamp2], \n",
    "                                          n_clusters):\n",
    "        \n",
    "    # group cluster nodes together\n",
    "    node_groups = [np.array(list(graph.nodes))[np.where(assignments == n)[0]] \\\n",
    "                   for n in np.unique(assignments)]\n",
    "\n",
    "    # extract edges within each cluster and between two clusters\n",
    "    inter_cluster_edges = []\n",
    "    intra_cluster_edges = []\n",
    "    \n",
    "    # iterate over all combinations of clusters\n",
    "    # -> extract inter-cluster edges\n",
    "    for cluster_i, cluster_j in itertools.combinations(range(_n_clusters), 2):\n",
    "        \n",
    "        _inter_cluster_edges = []\n",
    "\n",
    "        # max link between (each member of cluster i) and (all members of cluster j)\n",
    "        for node_i in node_groups[cluster_i]:\n",
    "            w_to_all_cluster_j = [graph.get_edge_data(node_i, node_j)['weight'] for \\\n",
    "                                  node_j in node_groups[cluster_j]]\n",
    "            _inter_cluster_edges.append(max(w_to_all_cluster_j))\n",
    "\n",
    "        # max link between (each member of cluster j) and (all members of cluster i)\n",
    "        for node_j in node_groups[cluster_j]:\n",
    "            w_to_all_cluster_i = [graph.get_edge_data(node_i, node_j)['weight'] for \\\n",
    "                                  node_i in node_groups[cluster_i]]\n",
    "            _inter_cluster_edges.append(max(w_to_all_cluster_i))\n",
    "        \n",
    "        inter_cluster_edges += _inter_cluster_edges\n",
    "\n",
    "    # iterate over every cluster\n",
    "    # -> extract intra-cluster edges\n",
    "    for cluster_i in range(_n_clusters):\n",
    "        \n",
    "        _intra_cluster_edges = []\n",
    "        \n",
    "        # max link within a single cluster of nodes, i.e., get max edge between node and \n",
    "        # all other members of the same cluster\n",
    "        for node_i in node_groups[cluster_i]:\n",
    "            w_to_all_in_cluster = [graph.get_edge_data(node_i, node_j)['weight'] for \\\n",
    "                                   node_j in node_groups[cluster_i] if node_i!=node_j]\n",
    "            if len(w_to_all_in_cluster) > 0:\n",
    "                _intra_cluster_edges.append(max(w_to_all_in_cluster))\n",
    "\n",
    "        intra_cluster_edges += _intra_cluster_edges\n",
    "\n",
    "    inter_cluster_edge_list.append(np.array(inter_cluster_edges))\n",
    "    intra_cluster_edge_list.append(np.array(intra_cluster_edges))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_dependency_graph(ax, _graph, pos_dict, assigments, edge_lcutoff=.3, nodelabels=False):\n",
    "    \"\"\"\n",
    "    Plots the dependency graph using networkx and matplotlib.pyplot.\n",
    "    :params:\n",
    "    :ax: plt.Axes object, populated by this function\n",
    "    :_graph: nx.Graph object, graph to show\n",
    "    :pos_dict: dict, contains positions of graph nodes\n",
    "    :assignments: list, assignment of colors (to match VMD output)\n",
    "    :edge_lcutoff: float, cutoff value for edge weights; everything \n",
    "    below will not be shown\n",
    "    :nodelabels: bool, optional, default: False. for matching clusters with VMD representation\n",
    "    \n",
    "    :returns:\n",
    "    :ax: populated plt.Axes object\n",
    "    :pc: matplotlib.collections.LineCollection of network edges\n",
    "    \"\"\"\n",
    "    # remove invisible paths from graph (decreases SVG file size later)\n",
    "    graph = nx.Graph()\n",
    "    graph.add_nodes_from(_graph.nodes)\n",
    "    for edge in _graph.edges():\n",
    "        w = _graph.get_edge_data(*edge)['weight']\n",
    "        if w > edge_lcutoff:\n",
    "            graph.add_edge(*edge, weight=w)\n",
    "    \n",
    "    weights = np.array(list(nx.get_edge_attributes(graph, 'weight').values()))\n",
    "\n",
    "    nx.draw_networkx_nodes(graph, \n",
    "                           node_size=nodesize,\n",
    "                           pos=pos_dict, \n",
    "                           ax=ax, \n",
    "                           node_color=vmd_colors[assigments])\n",
    "    \n",
    "    if nodelabels:\n",
    "        nx.draw_networkx_labels(graph, pos_dict, font_size=6)\n",
    "\n",
    "    pc = nx.draw_networkx_edges(graph, \n",
    "                                edge_color=weights, \n",
    "                                width=edgewidth, \n",
    "                                pos=pos_dict, \n",
    "                                node_size=nodesize,\n",
    "                                ax=ax, \n",
    "                                edge_cmap=edge_cmap, \n",
    "                                edge_vmax=1, \n",
    "                                edge_vmin=0\n",
    "                               )\n",
    "    \n",
    "    return ax, pc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_(gs, _graph, _pos_dict, _matched_assignment, _inter_cluster_edges, _intra_cluster_edges, ni=0, nf=-1):\n",
    "    fullax = fig.add_subplot(gs[:, ni:nf])\n",
    "    fullax.axis('off')\n",
    "\n",
    "    # network plot\n",
    "    ax = fig.add_subplot(gs[:, ni:ni+95])\n",
    "\n",
    "    ax, pc = plot_dependency_graph(ax, _graph, _pos_dict, _matched_assignment)\n",
    "    ax.axis('off')\n",
    "\n",
    "    # colorbar\n",
    "    cbar_ax = fig.add_subplot(gs[:, ni+102:ni+105])\n",
    "    cb = fig.colorbar(pc, cax=cbar_ax)\n",
    "\n",
    "    # histograms\n",
    "    ax = fig.add_subplot(gs[:, ni+125:nf])\n",
    "    sns.kdeplot(y=_inter_cluster_edges, fill=True, ax=ax, color=col_pal[0], linewidth=2)\n",
    "    sns.kdeplot(y=_intra_cluster_edges, fill=True, ax=ax, color=col_pal[1], linewidth=2)\n",
    "\n",
    "\n",
    "    ax.set_ylim(0, 1)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_xlabel('')\n",
    "\n",
    "    # comment following line to verify that axes are matching\n",
    "    for loc in ['top', 'right', 'bottom']:\n",
    "        ax.spines[loc].set_visible(False)\n",
    "    ax.set_yticklabels([]);\n",
    "    \n",
    "    return fullax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 960x360 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8, 3), dpi=120)\n",
    "gs = fig.add_gridspec(65, 320)\n",
    "\n",
    "ax = plot_(gs, graph_vamp1, pos_dicts[0], matched_assignments[0], inter_cluster_edge_list[0], intra_cluster_edge_list[0],\n",
    "           nf=140)\n",
    "ax.text(0, 1, r'$\\mathbf{(a)}$' + 11*' ' + 'VAMP-1', transform=ax.transAxes)\n",
    "ax = plot_(gs, graph_vamp2, pos_dicts[1], matched_assignments[1], inter_cluster_edge_list[1], intra_cluster_edge_list[1],\n",
    "           ni=180)\n",
    "ax.text(0, 1, r'$\\mathbf{(b)}$' + 11*' ' +'VAMP-2', transform=ax.transAxes)\n",
    "\n",
    "fig.savefig('/tmp/chignolin.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Please note that results are subject to stochasticity from Fruchterman-Reingold and k-means algorithms.\n",
    "\n",
    "# VAMP-1 network does not show significant differences between intra-cluster and inter-cluster\n",
    "# dependencies, i.e., no indication that dynamics can be decomposed into subsystems.\n",
    "# VAMP-2 network does not show any clustering at all.\n",
    "# Interpretation: Peptide is too small to express any independent subunits, IMD cannot be applied."
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}