latent_interpolation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from netgan.netgan import *\n",
    "import tensorflow as tf\n",
    "from netgan import utils\n",
    "import scipy.sparse as sp\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.metrics import roc_auc_score, average_precision_score\n",
    "import time\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_A_obs, _X_obs, _z_obs = utils.load_npz('data/cora_ml.npz')\n",
    "_A_obs = _A_obs + _A_obs.T\n",
    "_A_obs[_A_obs > 1] = 1\n",
    "lcc = utils.largest_connected_components(_A_obs)\n",
    "_A_obs = _A_obs[lcc,:][:,lcc]\n",
    "_z_obs = _z_obs[lcc]\n",
    "_N = _A_obs.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_share = 0.1\n",
    "test_share = 0.05\n",
    "seed = 481516234"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separate the edges into train, test, validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ones, val_ones, val_zeros, test_ones, test_zeros = utils.train_val_test_split_adjacency(_A_obs, val_share, test_share, seed, undirected=True, connected=True, asserts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_graph = sp.coo_matrix((np.ones(len(train_ones)),(train_ones[:,0], train_ones[:,1]))).tocsr()\n",
    "assert (train_graph.toarray() == train_graph.toarray().T).all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rw_len = 16\n",
    "batch_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "walker = utils.RandomWalker(train_graph, rw_len, p=1, q=1, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An example random walk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "walker.walk().__next__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create our NetGAN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netgan = NetGAN(_N, rw_len, walk_generator= walker.walk, gpu_id=1, use_gumbel=True, disc_iters=3,\n",
    "                W_down_discriminator_size=128, W_down_generator_size=128, noise_dim=2,\n",
    "                l2_penalty_generator=1e-7, l2_penalty_discriminator=5e-5,\n",
    "                generator_layers=[40], discriminator_layers=[30], temp_start=5, learning_rate=0.0003)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define the stopping criterion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stopping_criterion = \"val\"\n",
    "\n",
    "assert stopping_criterion in [\"val\", \"eo\"], \"Please set the desired stopping criterion.\"\n",
    "\n",
    "if stopping_criterion == \"val\": # use val criterion for early stopping\n",
    "    stopping = None\n",
    "elif stopping_criterion == \"eo\":  #use eo criterion for early stopping\n",
    "    stopping = 0.5 # set the target edge overlap here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_every = 2000\n",
    "plot_every = 2000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_dict = netgan.train(A_orig=_A_obs, val_ones=val_ones, val_zeros=val_zeros, stopping=stopping,\n",
    "                        eval_every=eval_every, plot_every=plot_every, max_patience=20, max_iters=200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(np.arange(len(log_dict['val_performances'])) * eval_every, \n",
    "         np.array(log_dict['val_performances'])[:,0], label=\"ROC-AUC\")\n",
    "plt.plot(np.arange(len(log_dict['val_performances'])) * eval_every,\n",
    "         np.array(log_dict['val_performances'])[:,1], label=\"Avg. Prec.\")\n",
    "\n",
    "plt.title(\"Validation performance during training\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(np.array(log_dict['edge_overlaps'])/_A_obs.sum())\n",
    "plt.title(\"Edge overlap during training\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generate random walks on the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_tf = tf.placeholder(tf.float32, shape=[10000, netgan.noise_dim])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_many = netgan.generate_discrete(10000, reuse=True, z=noise_tf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.special import ndtri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_walks = []\n",
    "all_noise = []\n",
    "before = time.time()\n",
    "iterations =   6000 #29144\n",
    "for it in range(iterations):\n",
    "    noise = np.random.uniform(low=0, high=1, size=[10000, netgan.noise_dim])\n",
    "    gaussian_noise = ndtri(noise)\n",
    "    walks = sample_many.eval(feed_dict={noise_tf: gaussian_noise, netgan.tau:0.5})\n",
    "    all_walks.extend(list(walks))\n",
    "    all_noise.extend(list(noise))\n",
    "    if (it+1) % 100 == 0:\n",
    "        elapsed = time.time() - before\n",
    "        print(\"{}/{} took {}, eta {}\".format(it+1, iterations, elapsed, iterations/(it+1)*elapsed - elapsed))\n",
    "\n",
    "np.savez_compressed(\"walks.npz\", \n",
    "                    walks = np.array(all_walks).astype(\"uint16\"),\n",
    "                    noise = np.array(all_noise))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_walks = np.array(all_walks)\n",
    "all_noise = np.array(all_noise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_walks.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_select = sp.csr_matrix((np.ones(len(train_ones)), (train_ones[:,0], train_ones[:,1])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Latent space heatmaps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_bins = 20\n",
    "bins = np.arange(0, 1, 1/n_bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_bins = np.floor(all_noise /  (1/n_bins)).astype('int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here we generate a graph from the random walks in each bin and measure their properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graphs_bins = [[None for i in range(n_bins)] for j in range(n_bins)]\n",
    "matrices = [[None for i in range(n_bins)] for j in range(n_bins)]\n",
    "statistics = [[None for i in range(n_bins)] for j in range(n_bins)]\n",
    "begin = time.time()\n",
    "it = 0\n",
    "\n",
    "for x1 in range(n_bins):\n",
    "    for x2 in range(n_bins):\n",
    "        it += 1\n",
    "        graphs_bins[x1][x2] = utils.score_matrix_from_random_walks(all_walks[np.where((noise_bins[:,0] == x1) &\n",
    "                                                                       (noise_bins[:,1] == x2))], netgan.N)\n",
    "        graph_select = utils.graph_from_scores(graphs_bins[x1][x2], A_select.sum())\n",
    "        matrices[x1][x2] = sp.coo_matrix(graph_select)\n",
    "        statistics[x1][x2] = utils.compute_graph_statistics(graph_select)\n",
    "        elapsed = time.time() - begin\n",
    "    print(\"{}/{} took {:.2f}, eta {:.2f}\".format(it, n_bins**2, elapsed, (n_bins**2)/(it)*elapsed - elapsed))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ks = list(statistics[0][0].keys())\n",
    "statistics_dict = {k: np.array([y[k] for x in statistics for y in x]).reshape((n_bins, n_bins)) for k in ks}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_nodes = all_walks[:,0]\n",
    "degrees = A_select.sum(0).A1\n",
    "unique, indices, counts = np.unique(first_nodes, return_counts=True, return_inverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_node_degrees = degrees[first_nodes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import entropy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here we compute some statistics of the random walks themselves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "entropies = np.zeros([n_bins, n_bins])\n",
    "one_comm = np.zeros([n_bins, n_bins])\n",
    "unique_nodes = np.zeros([n_bins, n_bins])\n",
    "first_node_comm = np.zeros([n_bins, n_bins])\n",
    "for x in range(n_bins):\n",
    "    print(x)\n",
    "    for y in range(n_bins):\n",
    "        sel = all_walks[(noise_bins[:,0] == x) & (noise_bins[:,1] == y),:]\n",
    "        ons = np.ones_like(sel)\n",
    "        first_node_communities = ons * np.expand_dims(_z_obs[sel[:,0]],1)\n",
    "        first_node_comm[x,y] = np.mean(_z_obs[sel] == first_node_communities)\n",
    "        \n",
    "        unique_firstnodes = np.unique(sel[:,0], return_counts=True)[1]\n",
    "        entr = entropy(unique_firstnodes) / np.log(len(unique_firstnodes))\n",
    "        entropies[x, y] = entr\n",
    "        \n",
    "        communities = _z_obs[sel]\n",
    "        share_one_community = (np.std(communities, axis=1) == 0).mean()\n",
    "        one_comm[x,y] = share_one_community\n",
    "        unique_nodes[x,y] = np.mean(list(map(len,(map(set,(map(tuple, sel)))))))\n",
    "        \n",
    "statistics_dict['unique_nodes'] = np.array(unique_nodes)\n",
    "statistics_dict['one_community'] = np.array(one_comm)\n",
    "statistics_dict['first_node_entropy'] = np.array(entropies)\n",
    "statistics_dict['first_node_community'] = np.array(first_node_comm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics_dict['claw_count'] = np.log(statistics_dict['claw_count'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics_dict['avg_starting_degree'] = np.array([np.mean(first_node_degrees[(noise_bins[:,0] == x) & (noise_bins[:,1] == y) ])\n",
    "       for x in range(n_bins) for y in range(n_bins)]).reshape((n_bins, n_bins))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Store the results to disk so that we don't have to run all of this again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez_compressed('intermediate/results_{}x{}.npz'.format(n_bins, n_bins), \n",
    "                    graphs = matrices,\n",
    "                    statistics = statistics_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load statistics from file (start here if you just want to run the visualization)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uncomment the following to load from disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#results = np.load('intermediate/results_{}x{}.npz'.format(n_bins, n_bins))\n",
    "#matrices = results['graphs']\n",
    "#statistics_dict = results['statistics'].item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('text', usetex=True)\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "def heatmap(scores, ax, title=None, cbar=True):  \n",
    "    pl = ax.imshow(np.array(scores), cmap='inferno', interpolation='nearest', extent=[0,1,0,1])\n",
    "\n",
    "    if title is not None:\n",
    "        plt.title(title, fontsize=15)\n",
    "\n",
    "    ax.set_xticks([0,1])\n",
    "    ax.get_yaxis().set_tick_params(labelsize=15)\n",
    "    ax.get_xaxis().set_tick_params(labelsize=15)\n",
    "    ax.set_yticks([0,1])\n",
    "    ax.set_xlabel(r'$\\Phi(\\mathbf{z}_1)$', labelpad=-13, fontsize=20)\n",
    "    ax.set_ylabel(r'$\\Phi(\\mathbf{z}_2)$', labelpad=-11, fontsize=20)\n",
    "    \n",
    "    if cbar:\n",
    "        divider = make_axes_locatable(ax)\n",
    "        cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n",
    "        cb = plt.colorbar(pl, cax=cax)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_keys = ['d_max', 'assortativity', 'triangle_count', 'wedge_count', 'power_law_exp',\n",
    "             'rel_edge_distr_entropy', 'LCC', 'claw_count', 'gini', 'unique_nodes', 'one_community',\n",
    "             'first_node_entropy','first_node_community', 'avg_starting_degree', 'cpl']\n",
    "\n",
    "display_titles = {'d_max': 'Max. degree', 'assortativity': 'Assortativity', 'triangle_count': 'Triangle count',\n",
    "                  'wedge_count': 'Wedge count', 'power_law_exp': 'Power law exponent',\n",
    "                  'rel_edge_distr_entropy':'Rel. edge distribution entropy', 'LCC': 'Largest connected component',\n",
    "                  'claw_count': 'Claw count', 'gini': 'Gini coefficient', \n",
    "                 'unique_nodes': 'Unique nodes per walk', 'one_community': 'Walks in single community',\n",
    "                  'first_node_entropy': 'Entropy of starting nodes', 'first_node_community': 'Share nodes in starting comm.',\n",
    "                 'avg_starting_degree': 'Avg. degree of first node', 'cpl': 'Characteristic path length'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x1080 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "from matplotlib import rcParams\n",
    "rcParams['axes.titlepad'] = 10 \n",
    "\n",
    "n_cols = 3\n",
    "n_rows = int(np.ceil(len(display_titles)/n_cols))\n",
    "fig=plt.figure(figsize=(4*n_cols,3*n_rows))\n",
    "\n",
    "gs = gridspec.GridSpec(n_rows, n_cols, hspace=0.4)\n",
    "\n",
    "for ix,key in enumerate(eval_keys):\n",
    "    ax = plt.subplot(gs[ix // n_cols, ix % n_cols])\n",
    "    vals = statistics_dict[key]\n",
    "    heatmap(vals, ax, cbar=True, title=display_titles[key])\n",
    "\n",
    "plt.savefig(\"intermediate/heatmaps.png\", dpi=150)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Community structure plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_bins_community = 10\n",
    "bins_community = np.arange(0, 1, 1/n_bins_community)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_bins_community = np.floor(all_noise /  (1/n_bins_community)).astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graphs = [[None for i in range(n_bins_community)] for j in range(n_bins_community)]\n",
    "begin = time.time()\n",
    "it = 0\n",
    "\n",
    "for x1 in range(n_bins_community):\n",
    "    for x2 in range(n_bins_community):\n",
    "        it += 1\n",
    "        scores = utils.score_matrix_from_random_walks(all_walks[np.where((noise_bins[:,0] == x1) &\n",
    "                                                                       (noise_bins[:,1] == x2))], netgan.N)\n",
    "        graph_select = utils.graph_from_scores(scores, A_select.sum())\n",
    "        graphs[x1][x2] = sp.coo_matrix(graph_select)\n",
    "        elapsed = time.time() - begin\n",
    "    print(\"{}/{} took {:.2f}, eta {:.2f}\".format(it, n_bins_community**2, elapsed, (n_bins_community**2)/(it)*elapsed - elapsed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_scores = utils.score_matrix_from_random_walks(all_walks, netgan.N)\n",
    "all_graph_select = utils.graph_from_scores(sp.coo_matrix(all_scores), A_select.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez_compressed('intermediate/results_communities_{}x{}.npz'.format(n_bins_community, n_bins_community), \n",
    "                    graphs = graphs,\n",
    "                    all_walks_graph = sp.csr_matrix(all_graph_select))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load statistics from file (start here if you just want to run the visualization)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uncomment the following to load from disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#n_bins_community = 10\n",
    "#results = np.load('intermediate/results_communities_{}x{}.npz'.format(noise_bins_community, noise_bins_community))\n",
    "#graphs = results['graphs']\n",
    "#all_graph_select = results['all_walks_graph'].item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_communities = _z_obs.max()+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distrs = []\n",
    "for x in range(len(graphs)):\n",
    "    for y in range(len(graphs[x])):\n",
    "        graph_internal = graphs[x][y]\n",
    "        edges = np.transpose(graph_internal.nonzero())\n",
    "        edges_communities = _z_obs[edges]\n",
    "        blocks = np.zeros((n_communities, n_communities))\n",
    "        blocks[edges_communities[:,0], edges_communities[:,1]] \n",
    "        tpls = list(map(tuple, edges_communities))\n",
    "        counts = Counter(tpls)\n",
    "        for k,v in counts.items():\n",
    "            blocks[k] = v\n",
    "        distrs.append(blocks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distrs = np.array(distrs).reshape([n_bins_community, n_bins_community,n_communities, n_communities])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x720 with 103 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.patches as patches\n",
    "from matplotlib import rcParams\n",
    "rcParams['axes.titlepad'] = 20 \n",
    "\n",
    "\n",
    "font = {'family': 'serif',\n",
    "        'weight': 'normal',\n",
    "        'size': 28,\n",
    "        'ha': 'center',\n",
    "        'va': 'center'\n",
    "        }\n",
    "\n",
    "fig = plt.figure(figsize=(11, 10))\n",
    "max_height = np.max(np.sum(distrs, axis=2))\n",
    "\n",
    "# gridspec inside gridspec\n",
    "outer_grid = gridspec.GridSpec(1, 2, wspace=0.02, hspace=0.0, width_ratios=[11, 1], bottom=0.13, left=0.13)\n",
    "\n",
    "inner_grid_1 = gridspec.GridSpecFromSubplotSpec(n_bins_community, n_bins_community,\n",
    "            subplot_spec=outer_grid[0], wspace=0.1, hspace=.1)\n",
    "\n",
    "for x_ix in range(distrs.shape[0]):\n",
    "    for y_ix in range(distrs.shape[1]):\n",
    "        ax = plt.Subplot(fig, inner_grid_1[x_ix, y_ix])\n",
    "        distr = distrs[x_ix][y_ix]\n",
    "        plot_normal = ax.bar(np.arange(n_communities), np.sum(distr, axis=0), color='#444444')\n",
    "\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "\n",
    "        fig.add_subplot(ax)\n",
    "        plt.ylim((0, max_height))\n",
    "        plt.axis('off')\n",
    "\n",
    "\n",
    "inner_grid_2 = gridspec.GridSpecFromSubplotSpec(n_bins_community, 1,\n",
    "            subplot_spec=outer_grid[1], wspace=0.0, hspace=0.1)\n",
    "\n",
    "# original graph\n",
    "ax = plt.Subplot(fig, inner_grid_2[int(n_bins_community/2)-1, 0])\n",
    "ax.patch.set_alpha(0.0)\n",
    "distr = np.zeros([n_communities, n_communities])\n",
    "graph_int = A_select\n",
    "for i in range(n_communities):\n",
    "    for j in range(n_communities):\n",
    "        sel = A_select[_z_obs ==i]\n",
    "        sel = sel[:,_z_obs == j]\n",
    "        distr[i,j] = sel.sum()\n",
    "plot_orig = ax.bar(np.arange(n_communities), np.sum(distr, axis=0),color='#386cb0')\n",
    "fig.add_subplot(ax)\n",
    "plt.ylim((0, max_height))\n",
    "plt.axis('off')\n",
    "\n",
    "# graph from all regions of z\n",
    "ax = plt.Subplot(fig, inner_grid_2[int(n_bins_community/2), 0])\n",
    "ax.patch.set_alpha(0.0)\n",
    "distr = np.zeros([n_communities, n_communities])\n",
    "graph_int = all_graph_select\n",
    "for i in range(n_communities):\n",
    "    for j in range(n_communities):\n",
    "        sel = all_graph_select[_z_obs ==i]\n",
    "        sel = sel[:,_z_obs == j]\n",
    "        distr[i,j] = sel.sum()\n",
    "plot_all_sample = ax.bar(np.arange(n_communities), np.sum(distr, axis=0),color='#999999')\n",
    "fig.add_subplot(ax)\n",
    "plt.ylim((0, max_height))\n",
    "plt.axis('off')\n",
    "\n",
    "\n",
    "all_axes = fig.get_axes()\n",
    "    \n",
    "ax = fig.add_subplot(111)\n",
    "ax.patch.set_alpha(0.0)\n",
    "\n",
    "ax.set_xticks(np.arange(0,1.1,0.1))\n",
    "ax.set_yticks(np.arange(0,1.1,0.1))\n",
    "plt.tick_params(axis='both', which='major', labelsize=20)\n",
    "text_left = plt.text(-0.1, 0.45, r'$\\Phi(\\mathbf{z}_2)$', fontdict=font, rotation=90)\n",
    "text_bot = plt.text(0.5, -0.1, r'$\\Phi(\\mathbf{z}_1)$', fontdict=font, rotation=0)\n",
    "plt.xlim((-.01, 1 + 1/n_bins_community))\n",
    "plt.ylim((-.015, .9785))\n",
    "for spine in plt.gca().spines.values():\n",
    "    spine.set_visible(False)\n",
    "plt.tick_params(top=False, bottom=False, left=False, right=False, labelleft=True, labelbottom=True)\n",
    "plt.title(\"Community distributions for subregions of $\\mathbf{z}$\", fontdict=font)\n",
    "lgd = plt.legend([plot_orig, plot_all_sample, plot_normal],\n",
    "           [\"Original community\\ndistribution\",\n",
    "            \"Community distribution on\\nall $\\mathbf{z}$ regions\",\n",
    "            \"Community distribution on\\n$\\mathbf{z}$ subregions\"],\n",
    "           bbox_to_anchor=(0.93, 0.3), labelspacing=.5, fontsize=16)\n",
    "ax.plot([-0.006,-.006],[-.011,.95] , 'k-', lw=1)\n",
    "ax.plot([.999,.999],[-.011,.95] , 'k--', lw=1)\n",
    "ax.plot([-0.006,.999],[-.011,-.011] , 'k-', lw=1)\n",
    "\n",
    "#plt.savefig( \"{}_community_distr_{}x{}.pdf\".format('cora', n_bins_community, n_bins_community),\n",
    "#           bbox_extra_artists=( text_left, text_bot), bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}