graph.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/fengwf/anaconda3/envs/zero/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/fengwf/anaconda3/envs/zero/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/fengwf/anaconda3/envs/zero/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/fengwf/anaconda3/envs/zero/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/fengwf/anaconda3/envs/zero/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/fengwf/anaconda3/envs/zero/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "#export\n",
    "from .imports import *\n",
    "from .core import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate random Directed Acyclic Graphs (DAG)\n",
    "There are many models to generate random graphs, but not enough models to generate random Directed Acyclic Graphs. \n",
    "\n",
    "One kind of methodology is first generating random undirected graphs, then translate to DAGs by sorting all the nodes.\n",
    "The other kind of methodology is generating random DAGs directly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### First generating random undirected graphs, then translate to DAGs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def build_graph(model:str=None, n:int=None, p:float=None, m:int=None, k:int=None):\n",
    "    \"\"\"\n",
    "    Generating undirected random graphs according to several common models\n",
    "\n",
    "    Parameters:\n",
    "    -----------\n",
    "\n",
    "    model : collection of random models: \n",
    "            ER - \n",
    "            BA -\n",
    "            PC - Powerlaw-Clustering\n",
    "            WS - \n",
    "    n     : number of nodes\n",
    "    p     : the probability of clustering in PC model, the probability of rewiring in WS model\n",
    "    m     : the number of new nodes added at each step, both in BA and PC models\n",
    "    k     : the average degree of all nodes both in ER model and in WS model\n",
    "    \"\"\"\n",
    "    is_connected = False\n",
    "    while not is_connected:\n",
    "        if model == 'ER':\n",
    "            G = nx.random_graphs.gnm_random_graph(n, k * n)\n",
    "        elif model == 'BA':\n",
    "            G = nx.random_graphs.barabasi_albert_graph(n, m)\n",
    "        elif model == 'PC':  # Powerlaw-Clustering\n",
    "            G = nx.random_graphs.powerlaw_cluster_graph(n, m, p)\n",
    "        elif model == 'WS':\n",
    "            G = nx.random_graphs.connected_watts_strogatz_graph(n, k*2, p, tries=200)\n",
    "        is_connected = nx.is_connected(G)\n",
    "        G.graph['n'] = n\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def to_DAG(G):\n",
    "    \"\"\"Translate an undirected graph to DAG.\"\"\"\n",
    "    # first, translated to a directed graph, \n",
    "    # where one undirected edge is tranformed to two directed edges\n",
    "    G = G.to_directed() \n",
    "    # then, delete edges whose input node is larger than its output node.\n",
    "    removed_edges = [(u,v) for (u,v) in G.edges if u >= v]  \n",
    "    G.remove_edges_from(removed_edges)\n",
    "    assert nx.dag.is_directed_acyclic_graph(G) #\n",
    "    return G\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "model = 'ER'; n = 10; k = 2; p = m = None\n",
    "#model = 'WS'; n = 40; k = 4; p = 0.5; m = None\n",
    "#model = 'BA'; n = 100; m = 4; k = p = None\n",
    "#model = 'PC'; n =100; m = 4; p = 0.75; k = None\n",
    "G = build_graph(model=model, n=n, p=p, m=m, k=k)\n",
    "print(G.number_of_edges())\n",
    "G = to_DAG(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### fitness model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def sample_fitness(n, k, p, sort:bool=False, reverse:bool=True):\n",
    "    \"\"\"\n",
    "    Generating (directed acyclic) random graphs based on fitness model.\n",
    "    \n",
    "    Parameters:\n",
    "    -----------\n",
    "    n : number of nodes. 节点个数\n",
    "    k : average degree of nodes. 节点平均度数\n",
    "    p : fitness coeff. of nodes, has such relation with the scale-free coeff. gamma: gamma = 1/p + 1\n",
    "    \"\"\"\n",
    "    weakly_connected = False\n",
    "    while not weakly_connected:\n",
    "        G = nx.DiGraph()\n",
    "        nodes = range(n)  # id of nodes, [0, n-1]\n",
    "        fitnesses = [math.pow(i+1, -p) for i in nodes]\n",
    "        if sort:\n",
    "            fitnesses = sorted(fitnesses, reverse=reverse)\n",
    "        fitnesses_norm = [fitness / sum(fitnesses) for fitness in fitnesses]\n",
    "        while G.number_of_edges() < n*k:\n",
    "            node1, node2 = np.random.choice(nodes, 2, replace=False, p = fitnesses_norm)\n",
    "            if node1 < node2:\n",
    "                G.add_edge(node1, node2)\n",
    "            else:\n",
    "                G.add_edge(node2, node1)\n",
    "        weakly_connected = nx.is_weakly_connected(G)\n",
    "        \n",
    "    G.graph['n'] = n\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = sample_fitness(n=50, k=2, p=1, sort=False, reverse=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Niche models\n",
    " 1. Cascade model of food webs.\n",
    " 2. Niche model of food webs.\n",
    " 3. Trophic coherent of food webs.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The niche model uses two fundamental parameters, connectance and number of species, and relies on a one-dimensional niche space or hierarchy. \n",
    "Species are given a random niche value $n_i \\sim Uniform(0,1)$ in the hierarchy.\n",
    "Diets are assigned to each species independently by generating a center and a range as follows. \n",
    "Firstly, the feeding range is given by $r_i = n_i x_i$ where $x_i$ is a random number drawn from a Beta distribution, with equation $x_i \\sim Beta(\\alpha=1,\\beta)$. The distribution is chosen to obtain, on average, the desired connectance. \n",
    "Secondly, the centers of the feeding ranges are chosen randomly from species further down in the hierarchy, with equation $c_i \\sim Uniform (r_i/2,n_i)$. Once a feeding range is established for a given species, all species in that range become its prey. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def cascade(s:int, c:float):\n",
    "    p = (2 * c * s) / (s - 1)\n",
    "    A = np.zeros((s,s))\n",
    "    weakly_connected = False\n",
    "    while not weakly_connected:\n",
    "        for i in range(s-1):\n",
    "            A[i,(i+1):] = np.random.binomial(size=s-i-1, n=1, p=p)\n",
    "        G=nx.from_numpy_matrix(A, create_using=nx.DiGraph())\n",
    "        weakly_connected = nx.is_weakly_connected(G)\n",
    "\n",
    "    G.graph['n'] = s\n",
    "    G.graph['c'] = c\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = cascade(20, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def niche(s:int, c:int, flip_diag:bool=True):\n",
    "    \"\"\"\n",
    "    Niche Model for Food Web\n",
    "    \n",
    "    Args:\n",
    "    s: number of species in the community\n",
    "    c: the connectance, or fraction of realized links in the food web\n",
    "    \n",
    "    Returns:\n",
    "    a weakly connected DAG (Directed Acyclic Graph) for a niche model food web.\n",
    "    \"\"\"\n",
    "    weakly_connected = False\n",
    "    while not weakly_connected:\n",
    "        b = 1 / (2 * c) - 1\n",
    "        ni = sorted(np.random.uniform(size = s))\n",
    "        ri = np.random.beta(a = 1, b = b, size = s) * ni\n",
    "        ci = np.random.uniform(size = s, low = ri / 2, high = np.minimum(ni, 1 - ri / 2))\n",
    "        A = np.zeros((s,s))\n",
    "        for i in range(s):\n",
    "            for j in range(i+1, s): # 1\n",
    "                if ni[i] > ci[j] - .5 * ri[j] and ni[i] < ci[j] + .5 * ri[j]:\n",
    "                    A[i,j] = 1\n",
    "        if flip_diag:\n",
    "            A = np.flip(np.rot90(A), axis=1) # rotate 90 degree anti-clockly, then flip along column\n",
    "        G=nx.from_numpy_matrix(A, create_using=nx.DiGraph())\n",
    "        weakly_connected = nx.is_weakly_connected(G)\n",
    "    G.graph['n'] = s\n",
    "    G.graph['c'] = c\n",
    "    return G  #A,   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = niche(20, 0.1, flip_diag=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preferential_prey(B, N, L, T):\n",
    "    \"\"\"\n",
    "    The Preferential Preying Model\n",
    "    \"\"\"\n",
    "\n",
    "    b = (N**2 - B**2) / (2*L) - 1 # beta parameters of Beta distribution\n",
    "    # create graph, add basal nodes and basal trophic levels\n",
    "    G = nx.DiGraph()\n",
    "    G.add_nodes_from(range(0,B))\n",
    "    nx.set_node_attributes(G, 1, 's') # 0 OR 1\n",
    "\n",
    "    # add nodes and ki links one at a time\n",
    "    for node in range(B, N):\n",
    "        ni = G.number_of_nodes()\n",
    "        # create link probabilities\n",
    "        s = np.fromiter(nx.get_node_attributes(G, 's').values(),\n",
    "                       dtype=float)\n",
    "        # the first prey node\n",
    "        randNode = np.random.choice(G.nodes())\n",
    "        sl = G.node[randNode]['s']\n",
    "        probs = np.exp(-np.abs(s-sl)/T)\n",
    "        probs[randNode] = 0\n",
    "        sumProbs = probs.sum()\n",
    "        probs = probs / sumProbs\n",
    "        # add ki\n",
    "        ki = int(np.round(np.random.beta(a = 1, b = b, size = 1) * ni))\n",
    "        probs = probs * ki\n",
    "\n",
    "        # draw random numbers\n",
    "        r = np.random.rand(probs.shape[0])\n",
    "\n",
    "        # define edges to be made\n",
    "        edges = probs > r\n",
    "        for i, edge in enumerate(edges):\n",
    "            if edge:\n",
    "                G.add_edge(i, node)\n",
    "\n",
    "        G.add_edge(randNode, node)\n",
    "\n",
    "        # calculate trophic level of new node\n",
    "        preds = [G.node[pred]['s'] for pred in G.predecessors(node)]\n",
    "#         print(preds)\n",
    "        G.node[node]['s'] = sum(preds) / len(preds) + 1\n",
    "\n",
    "    G.graph['n'] = N\n",
    "    \n",
    "    return G\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = preferential_prey(B=5, N=50, L=200, T=100.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add an unique input node and an unique output node for DAG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "def after_DAG(G, option:str=None):\n",
    "    \"\"\"\n",
    "    Add an unique input node and an unique output node for DAG.\n",
    "    There are two options to add these two new nodes.\n",
    "    First is to connect the new input node to nodes which have zero input degree in the origin DAG,\n",
    "    and connect nodes which have zero output degree to the new output node.\n",
    "    Second is to connect the new input node to all nodes in the origin DAG,\n",
    "    and connect all node in the origin DAG to the new output node.\n",
    "    \"\"\"\n",
    "    n = G.graph['n'] # number of nodes\n",
    "    \n",
    "    # find all input nodes and output nodes\n",
    "    if option == 'all':\n",
    "        in_nodes = out_nodes = range(n)\n",
    "    else:\n",
    "        in_nodes = [v for v, d in G.in_degree() if d==0]\n",
    "        out_nodes = [v for v, d in G.out_degree() if d==0]\n",
    "    # number of input nodes, number of output nodes, length of longest path\n",
    "    # len(in_nodes), len(out_nodes), \n",
    "\n",
    "    # add a node with id: -1 as the unique input node\n",
    "    in_edges = [(-1,i) for i in in_nodes] \n",
    "    G.add_edges_from(in_edges)\n",
    "    # add a node with id: n as the unique output node\n",
    "    out_edges = [(i, n) for i in out_nodes] \n",
    "    G.add_edges_from(out_edges)\n",
    "    \n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = after_DAG(G)\n",
    "\n",
    "#G = after_DAG(G, option='all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,-1,50,"
     ]
    }
   ],
   "source": [
    "for id in G.nodes():\n",
    "    print(id, end=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, 14)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nx.is_directed_acyclic_graph(G), nx.dag.dag_longest_path_length(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of random DAGs\n",
    "\n",
    "Summary information of a DAG. The information reflect structural features of a DAG that may influence on the performance of corresponding neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def paths_DAG(G):\n",
    "    \"\"\"\n",
    "    All paths from the unique input node to the unique output node.\n",
    "    The DAG is first transformed to a matrix, then the number of paths \n",
    "    with length `i` can be calculated as an element of `i` power of the matrix.\n",
    "    \n",
    "    Returns:\n",
    "    --------\n",
    "    \n",
    "    \"\"\"\n",
    "    n = nx.number_of_nodes(G) # get node number\n",
    "    \n",
    "    # first, tranform to matrix, nodes are sorted by their IDs\n",
    "    mat = nx.to_numpy_matrix(G, nodelist=sorted(G.nodes()))\n",
    "    \n",
    "    start = True\n",
    "    paths = OrderedDict() # key: the length of paths, value: the number of paths with particular length\n",
    "    for i in range(1, n):\n",
    "        mat_power = matrix_power(mat,i)\n",
    "        num_paths = int(mat_power[0,-1]) # number of paths with length `i` from the input node to the output node\n",
    "        if num_paths != 0 and start: # paths with the least length\n",
    "            start = False\n",
    "            paths[i] = num_paths\n",
    "        elif num_paths == 0 and not start: # after the longest length\n",
    "            break\n",
    "        else:\n",
    "            paths[i] = num_paths\n",
    "    return paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([(1, 0), (2, 0), (3, 4), (4, 8), (5, 26)])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "paths_DAG(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def summary_DAG(G):\n",
    "    \"\"\"\n",
    "    Summary information of a DAG. The information reflect structural features of\n",
    "    a DAG that may influence on the performance of corresponding neural network.\n",
    "    \n",
    "    Returns:\n",
    "    --------\n",
    "    \n",
    "    num_nodes : number of nodes\n",
    "    num_edges : number of edges\n",
    "    num_real_nodes : number of real nodes, except the unique input and output nodes.\n",
    "    \n",
    "    average clustering : (undirected)\n",
    "    transitivity : (undirected)\n",
    "    transitivity : (directed)\n",
    "\n",
    "    in_nodes : list of IDs of all input nodes.\n",
    "    num_in_nodes : number of input nodes.\n",
    "    out_nodes : list of IDs of all output nodes.\n",
    "    num_out_nodes : number of output nodes.\n",
    "    \n",
    "    paths : dict of all paths from the input node to the output node\n",
    "    max_length : max length of all path from the input node to the output node\n",
    "    num_paths : number of all paths from the input node to the output node\n",
    "    \n",
    "    \"\"\"\n",
    "    num_nodes = G.number_of_nodes()\n",
    "    num_edges = G.number_of_edges()\n",
    "    num_real_nodes = G.graph['n']\n",
    "    \n",
    "    average_clustering = nx.average_clustering(nx.to_undirected(G))\n",
    "    transitivity = nx.transitivity(nx.to_undirected(G))\n",
    "    transitivity_directed = nx.transitivity(G)\n",
    "    \n",
    "    # find all input nodes and output nodes\n",
    "    in_nodes = [v for v, d in G.in_degree() if d==0]\n",
    "    num_in_nodes = len(in_nodes)\n",
    "    out_nodes = [v for v, d in G.out_degree() if d==0]\n",
    "    num_out_nodes = len(out_nodes)\n",
    "\n",
    "    paths = max_length = num_paths = None\n",
    "    \n",
    "    #if the unique input node and the unique output node have been added\n",
    "    if num_in_nodes == 1 and num_out_nodes == 1 and num_real_nodes != num_nodes:\n",
    "        in_nodes = [*G.successors(-1)]\n",
    "        num_in_nodes = len(in_nodes)\n",
    "        out_nodes = [*G.predecessors(G.graph['n'])]\n",
    "        num_out_nodes = len(out_nodes)\n",
    "        \n",
    "        paths = paths_DAG(G)\n",
    "        max_length = max(paths.keys())\n",
    "        num_paths = sum(paths.values())\n",
    "#         paths = nx.all_simple_paths(G, source=-1, target=num_real_nodes)\n",
    "#         len_paths = [len(path)-1 for path in paths]\n",
    "#         len_paths = np.array(len_paths)\n",
    "#         path_lens, path_counts = np.unique(len_paths, return_counts=True)\n",
    "#         num_paths = len(len_paths)\n",
    "        \n",
    "    print(' number of nodes :', num_nodes, '\\n',\n",
    "          'number of edges :', num_edges, '\\n',\n",
    "          'average node degree : %.4f' % (num_edges/num_nodes), '\\n',\n",
    "          'number of real nodes :', num_real_nodes, '\\n',\n",
    "          'average clustering (undirected) : %.4f' % average_clustering, '\\n',\n",
    "          'transitivity (undirected) : %.4f' % transitivity, '\\n',\n",
    "          'transitivity (directed) : %.4f' % transitivity_directed, '\\n',\n",
    "          'input nodes : ', in_nodes, '\\n',\n",
    "          'number of input nodes :', num_in_nodes, '\\n',\n",
    "          'output nodes : ', out_nodes, '\\n',\n",
    "          'number of output nodes :', num_out_nodes, '\\n',\n",
    "          'all paths :', paths, '\\n',\n",
    "          'max length of all paths :', max_length, '\\n',\n",
    "          'number of all paths :', num_paths, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " number of nodes : 22 \n",
      " number of edges : 43 \n",
      " average node degree : 1.9545 \n",
      " number of real nodes : 20 \n",
      " average clustering (undirected) : 0.0812 \n",
      " transitivity (undirected) : 0.1040 \n",
      " transitivity (directed) : 0.0652 \n",
      " input nodes :  [0, 1, 2] \n",
      " number of input nodes : 3 \n",
      " output nodes :  [7, 8, 11, 13, 14, 15, 16, 17, 18, 19] \n",
      " number of output nodes : 10 \n",
      " all paths : OrderedDict([(1, 0), (2, 0), (3, 4), (4, 8), (5, 26)]) \n",
      " max length of all paths : 5 \n",
      " number of all paths : 38 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "summary_DAG(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualization of random DAGs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nx.draw(G ,pos=nx.circular_layout(G),with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7ffa837ecdd0>"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "A = nx.to_numpy_matrix(G, nodelist=sorted(G.nodes()))\n",
    "plt.spy(A, markersize=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted graph.ipynb to zero/graph.py\r\n"
     ]
    }
   ],
   "source": [
    "!python notebook2script.py graph.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}