python_scripts/FlywireAnalysis/v630-Animal-Comparison.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "from time import time\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "from utils.utils import *\n",
    "from utils.graph_creation import *\n",
    "from utils.motif_counts import *\n",
    "from utils.visualization import *\n",
    "import graph_tool.all as gt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_context(\"talk\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ver = 630\n",
    "fdir = \"/mnt/cup/labs/seung/research/runzhey/datasets/FlyWire/{}/syn_proof_analysis_ntavg_{}.feather\".format(ver, ver)\n",
    "# fdir = \"~/seungmount/research/runzhey/datasets/FlyWire/{}/syn_proof_analysis_ntavg_{}.feather\".format(ver, ver)\n",
    "syn_table = pd.read_feather(fdir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Graph Construction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# build index dictionary\n",
    "cellids =  np.unique(syn_table[[\"pre_pt_root_id\", \"post_pt_root_id\"]])\n",
    "nid2cid = {i: cid for i, cid in enumerate(cellids)}\n",
    "cid2nid = {cid: i for i, cid in enumerate(cellids)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "syn_table[\"pre_nid\"] = pd.Series([cid2nid[cid] for cid in syn_table[\"pre_pt_root_id\"]], \n",
    "                                 index=syn_table.index)\n",
    "syn_table[\"post_nid\"] = pd.Series([cid2nid[cid] for cid in syn_table[\"post_pt_root_id\"]], \n",
    "                                 index=syn_table.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_syn_table = syn_table[[\"pre_nid\", \"post_nid\", \"syn_count\"]\n",
    "                           ].groupby(by=[\"pre_nid\", \"post_nid\"]).sum().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_edge_list = [(e[0], e[1], e[2]) for e in merged_syn_table.values]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_fly = gt.Graph()\n",
    "g_fly.add_vertex(len(cellids))\n",
    "e_syn_count = g_fly.new_ep(\"int32_t\")\n",
    "g_fly.add_edge_list(merged_edge_list, eprops=[e_syn_count])\n",
    "g_fly.vp[\"cellid\"] = g_fly.new_vp(\"int64_t\")\n",
    "g_fly.vp[\"cellid\"].a = cellids\n",
    "g_fly.ep[\"syn_count\"] = e_syn_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph object, directed, with 127319 vertices and 14680950 edges, 1 internal vertex property, 1 internal edge property, at 0x7fb1b466ff50>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# merged weightedd graph\n",
    "g_fly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "strong_filter = g_fly.new_ep('bool')\n",
    "for e in g_fly.edges():\n",
    "    strong_filter[e] = True if g_fly.ep[\"syn_count\"][e] >=5 else False\n",
    "g_fly.set_edge_filter(strong_filter)\n",
    "g_fly_th5 = gt.Graph(g_fly, prune=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph object, directed, with 127319 vertices and 2613129 edges, 1 internal vertex property, 1 internal edge property, at 0x7fb16ff58190>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# merged weightedd graph\n",
    "g_fly_th5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Worm-male"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SI2 is weighted by synapse count\n",
    "connmat = pd.read_excel(\"../ZfishModularity/data/SI2-male-chem.xlsx\", engine=\"openpyxl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_rid2name = dict(connmat[\"Unnamed: 0\"])\n",
    "cell_name2rid = dict(zip(list(cell_rid2name.values()), range(len(cell_rid2name))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "col_spec_cell_names = list(connmat.keys())[1:]\n",
    "for n in np.array(connmat[\"Unnamed: 0\"]):\n",
    "    col_spec_cell_names.remove(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rearrange column order\n",
    "cell_names = list(connmat[\"Unnamed: 0\"]) + col_spec_cell_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "connmat = connmat[cell_names]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_worm_male = gt.Graph()\n",
    "idx = np.array(connmat.fillna(0)).nonzero()\n",
    "g_worm_male.add_edge_list(np.transpose(idx))\n",
    "\n",
    "ew = g_worm_male.new_edge_property(\"int32_t\")\n",
    "ew.a = np.array(connmat.fillna(0))[idx] \n",
    "g_worm_male.ep['syn_count'] = ew\n",
    "\n",
    "vw = g_worm_male.new_vertex_property(\"string\")\n",
    "for i, v in enumerate(g_worm_male.vertices()):\n",
    "    vw[v] = cell_names[i]\n",
    "g_worm_male.vp['cell_name'] = vw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_type = pd.read_excel(\"../ZfishModularity/data/SI4-combined-celltype.xlsx\", engine=\"openpyxl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_name2type = dict(zip(list(cell_type[\"cell name\"]), list(cell_type[\"cell category\"])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "vw = g_worm_male.new_vertex_property(\"string\")\n",
    "for i, v in enumerate(g_worm_male.vertices()):\n",
    "    name = g_worm_male.vp['cell_name'][v]\n",
    "    if name in cell_name2type.keys():\n",
    "        vw[v] = cell_name2type[name]\n",
    "    else:\n",
    "        vw[v] = \"others\"\n",
    "g_worm_male.vp['cell_type'] = vw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "neuron_filter = g_worm_male.new_vertex_property(\"bool\")\n",
    "for v in g_worm_male.vertices():\n",
    "    neuron_filter[v] = g_worm_male.vp['cell_type'][v] not in ['endorgan', 'muscle']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_worm_male.set_vertex_filter(neuron_filter)\n",
    "g_worm_male = gt.Graph(g_worm_male, prune=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph object, directed, with 364 vertices and 3467 edges, 2 internal vertex properties, 1 internal edge property, at 0x7faeea2d4e10>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g_worm_male"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Worm-herm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SI2 is weighted by synapse count\n",
    "connmat = pd.read_excel(\"../ZfishModularity/data/SI2-herm-chem.xlsx\", engine=\"openpyxl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_rid2name = dict(connmat[\"Unnamed: 0\"])\n",
    "cell_name2rid = dict(zip(list(cell_rid2name.values()), range(len(cell_rid2name))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "col_spec_cell_names = list(connmat.keys())[1:]\n",
    "for n in np.array(connmat[\"Unnamed: 0\"]):\n",
    "    col_spec_cell_names.remove(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rearrange column order\n",
    "cell_names = list(connmat[\"Unnamed: 0\"]) + col_spec_cell_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "connmat = connmat[cell_names]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_worm_herm = gt.Graph()\n",
    "idx = np.array(connmat.fillna(0)).nonzero()\n",
    "g_worm_herm.add_edge_list(np.transpose(idx))\n",
    "\n",
    "ew = g_worm_herm.new_edge_property(\"int32_t\")\n",
    "ew.a = np.array(connmat.fillna(0))[idx] \n",
    "g_worm_herm.ep['syn_count'] = ew\n",
    "\n",
    "vw = g_worm_herm.new_vertex_property(\"string\")\n",
    "for i, v in enumerate(g_worm_herm.vertices()):\n",
    "    vw[v] = cell_names[i]\n",
    "g_worm_herm.vp['cell_name'] = vw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_type = pd.read_excel(\"../ZfishModularity/data/SI4-combined-celltype.xlsx\", engine=\"openpyxl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_name2type = dict(zip(list(cell_type[\"cell name\"]), list(cell_type[\"cell category\"])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "vw = g_worm_herm.new_vertex_property(\"string\")\n",
    "for i, v in enumerate(g_worm_herm.vertices()):\n",
    "    name = g_worm_herm.vp['cell_name'][v]\n",
    "    if name in cell_name2type.keys():\n",
    "        vw[v] = cell_name2type[name]\n",
    "    else:\n",
    "        vw[v] = \"others\"\n",
    "g_worm_herm.vp['cell_type'] = vw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "neuron_filter = g_worm_herm.new_vertex_property(\"bool\")\n",
    "for v in g_worm_herm.vertices():\n",
    "    neuron_filter[v] = g_worm_herm.vp['cell_type'][v] not in ['endorgan', 'muscle']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_worm_herm.set_vertex_filter(neuron_filter)\n",
    "g_worm_herm = gt.Graph(g_worm_herm, prune=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph object, directed, with 302 vertices and 3242 edges, 2 internal vertex properties, 1 internal edge property, at 0x7faeea2eded0>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g_worm_herm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Zebrafish center subgraph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_zfish = gt.load_graph(\"../ZfishModularity/saved/gt-ax50-dd100.xml.gz\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_zfish.ep[\"syn_count\"] = g_zfish.ep[\"#synapses\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph object, directed, with 419 vertices and 5605 edges, 18 internal vertex properties, 3 internal edge properties, at 0x7faeea2f03d0>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g_zfish"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pinky th100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyc_synapses = pd.read_csv('../PinkyMotif/motif_cleaned/motif_analysis/data/synapses.csv')\n",
    "pyc_soma = pd.read_csv('../PinkyMotif/motif_cleaned/motif_analysis/data/soma.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_thresholded_graph(g, axls, th):\n",
    "    rg = g.copy()\n",
    "    for n in g.nodes:\n",
    "        if axls[n] <= th:\n",
    "            rg.remove_node(n)\n",
    "    return rg\n",
    "\n",
    "def remove_autapses(g):\n",
    "    rg = g.copy()\n",
    "    for e in g.edges:\n",
    "        if e[0] == e[1]:\n",
    "            rg.remove_edge(*e)\n",
    "    return rg\n",
    "\n",
    "def synapses_to_connections(df):\n",
    "    return df[['pre','post']].drop_duplicates(subset=['pre','post'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the simple directed graph (no self-loops, no multi-edges)\n",
    "# treat multiple synapses as one connection\n",
    "pyc_subgraph = synapses_to_connections(pyc_synapses[['pre','post']])\n",
    "# remove self-loops\n",
    "g_actual = remove_autapses(edges_to_graph(pyc_subgraph))\n",
    "g_actual.add_nodes_from(pyc_soma[\"segment_id\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: \n",
      "Type: DiGraph\n",
      "Number of nodes: 363\n",
      "Number of edges: 1750\n",
      "Average in degree:   4.8209\n",
      "Average out degree:   4.8209\n"
     ]
    }
   ],
   "source": [
    "print(nx.info(g_actual))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "axls = {n:np.array(pyc_soma[pyc_soma[\"segment_id\"] == n][\"axon_len\"])[0] for n in g_actual.nodes()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: \n",
      "Type: DiGraph\n",
      "Number of nodes: 111\n",
      "Number of edges: 659\n",
      "Average in degree:   5.9369\n",
      "Average out degree:   5.9369\n"
     ]
    }
   ],
   "source": [
    "g_th100 = get_thresholded_graph(g_actual, axls, 100)\n",
    "print(nx.info(g_th100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_mouse = nx2gt(g_th100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_mouse.ep[\"syn_count\"] = g_mouse.new_edge_property(\"int32_t\")\n",
    "for e in g_mouse.edges():\n",
    "    g_mouse.ep[\"syn_count\"][e] = len(pyc_synapses[(pyc_synapses[\"pre\"] == int(g_mouse.vp[\"id\"][e.source()])) \n",
    "                                                  & (pyc_synapses[\"post\"] == int(g_mouse.vp[\"id\"][e.target()]))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph object, directed, with 111 vertices and 659 edges, 1 internal vertex property, 1 internal edge property, at 0x7faeea2c2910>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g_mouse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_fly.clear_filters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_nns = g_fly, g_fly_th5, g_worm_herm, g_worm_male, g_zfish, g_mouse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Graph object, directed, with 127319 vertices and 14680950 edges, 1 internal vertex property, 1 internal edge property, at 0x7fb1b466ff50>,\n",
       " <Graph object, directed, with 127319 vertices and 2613129 edges, 1 internal vertex property, 1 internal edge property, at 0x7fb16ff58190>,\n",
       " <Graph object, directed, with 302 vertices and 3242 edges, 2 internal vertex properties, 1 internal edge property, at 0x7faeea2eded0>,\n",
       " <Graph object, directed, with 364 vertices and 3467 edges, 2 internal vertex properties, 1 internal edge property, at 0x7faeea2d4e10>,\n",
       " <Graph object, directed, with 419 vertices and 5605 edges, 18 internal vertex properties, 3 internal edge properties, at 0x7faeea2f03d0>,\n",
       " <Graph object, directed, with 111 vertices and 659 edges, 1 internal vertex property, 1 internal edge property, at 0x7faeea2c2910>)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g_nns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0009056723997342875,\n",
       " 0.00016120474575863678,\n",
       " 0.03566478185298454,\n",
       " 0.02623891260254897,\n",
       " 0.03200260360164894,\n",
       " 0.05397215397215398]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conn_p = [g.num_edges() / g.num_vertices() / (g.num_vertices()-1) for g in g_nns]\n",
    "conn_p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  5.61814974,   1.        , 221.23903167, 162.76761878,\n",
       "       198.52147312, 334.80499422])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(conn_p) / conn_p[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5947458441040943\n",
      "12.617289846769907\n",
      "3.147131400370142\n",
      "3.594750504759158\n",
      "1.6897413024085637\n",
      "1.1411229135053111\n"
     ]
    }
   ],
   "source": [
    "for g in g_nns:\n",
    "    print(sum(g.ep[\"syn_count\"].a)/g.num_edges())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2358\n",
      "2358\n",
      "36\n",
      "63\n",
      "21\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for g in g_nns:\n",
    "    print(max(g.ep[\"syn_count\"].a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.26551919324021944,\n",
       " 0.13837740119221056,\n",
       " 0.3723010487353485,\n",
       " 0.3862128641476781,\n",
       " 0.11311329170383586,\n",
       " 0.08801213960546282]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reciprocities = [gt.edge_reciprocity(g) for g in g_nns]\n",
    "reciprocities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([293.17355074, 858.39533161,  10.43889881,  14.71908802,\n",
       "         3.53450279,   1.63069533])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(reciprocities) / np.array(conn_p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2min 6s, sys: 967 ms, total: 2min 7s\n",
      "Wall time: 9.14 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.10804973088935205,\n",
       " 0.04632866099163119,\n",
       " 0.28430426432509387,\n",
       " 0.33116515048737655,\n",
       " 0.18198723638054182,\n",
       " 0.15868044681073182]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "cluster_coefs = [gt.global_clustering(g)[0] for g in g_nns]\n",
    "cluster_coefs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 327 µs, sys: 12 µs, total: 339 µs\n",
      "Wall time: 355 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 59.67868841, 143.70667338,   4.05815096,   6.39446497,\n",
       "         2.88955588,   1.51079178])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "conn_p = np.array(conn_p)\n",
    "undir_conn_p = 1 - (1-conn_p)**2\n",
    "cluster_coefs / undir_conn_p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6h 18min 15s, sys: 2min 3s, total: 6h 20min 18s\n",
      "Wall time: 1h 19min 53s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "cfg_rec = []\n",
    "cfg_cls = []\n",
    "for i, g in enumerate(g_nns):\n",
    "    cfg_rec.append([])\n",
    "    cfg_cls.append([])\n",
    "    cfg_g = gt.Graph(g)\n",
    "    for _ in range(100):\n",
    "        gt.random_rewire(cfg_g)\n",
    "        cfg_rec[i].append(gt.edge_reciprocity(cfg_g))\n",
    "        cfg_cls[i].append(gt.global_clustering(cfg_g)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([46.07720019, 43.7444805 ,  4.98554316,  5.95932173,  2.60540807,\n",
       "        1.41050584])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reciprocities / np.mean(cfg_rec, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9.17835287, 7.56014674, 1.86857217, 2.40084297, 1.8933038 ,\n",
       "       1.05695749])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cluster_coefs / np.mean(cfg_cls, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "playground",
   "language": "python",
   "name": "myenv"
  },
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}