Basic Pieces of Causal Bayesian NetworkX.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import networkx as nx\n",
    "from itertools import chain, combinations, tee\n",
    "from graph_enumerator import powerset\n",
    "\n",
    "# For richer sets of operations on graphs, see the graph_enumerator module.\n",
    "# from graph_enumerator import *\n",
    "# "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Operations over sets of graphs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def completeDiGraph(nodes):\n",
    "    \"\"\"\n",
    "    returns a directed graph with all possible edges\n",
    "    \n",
    "    Variables:\n",
    "    nodes are a list of strings that specify the node names\n",
    "    \"\"\"\n",
    "    G = nx.DiGraph()\n",
    "    G.add_nodes_from(nodes)\n",
    "    edgelist = list(combinations(nodes,2))\n",
    "    edgelist.extend([(y,x) for x,y in edgelist])\n",
    "    edgelist.extend([(x,x) for x in nodes])\n",
    "    G.add_edges_from(edgelist)\n",
    "    return G\n",
    "\n",
    "def conditionalSubgraphs(G,condition_list):\n",
    "    \"\"\"\n",
    "    Returns a graph generator/iterator such that any conditions specified in condition_list \n",
    "    are met by some subgraph of G.\n",
    "    This is intended to be used in conjunction with completeDiGraph or any graph which subgraphs \n",
    "    are expected to be taken.\n",
    "    \n",
    "    Variables: \n",
    "    G is a graph from which subgraphs will be taken.\n",
    "    condition_list is a list of first order functions that define conditions subgraphs of G need to meet to be output.\n",
    "    Functions in condition_list should return a single boolean value for every graph passed into them.\n",
    "    \"\"\"\n",
    "    try: \n",
    "        condition_list[0]\n",
    "    except TypeError:\n",
    "        raise TypeError(\"\"\"\n",
    "        Subsampling from a graph requires passing in a list of conditions encoded\n",
    "        as first-class functions that accept networkX graphs as an input and return boolean values.\"\"\")\n",
    "    \n",
    "    for edges in powerset(G.edges()):\n",
    "        G_test = G.copy()\n",
    "        G_test.remove_edges_from(edges)\n",
    "        if all([c(G_test) for c in condition_list]):\n",
    "            yield G_test\n",
    "\n",
    "def create_no_self_loops_condition():\n",
    "    \"\"\"\n",
    "    This factory allows us to specify that there are no valid self-loops\n",
    "    This returns a function that takes an graph argument (G). \n",
    "    \n",
    "    NB: This is a common assumption of causal graphs, because they are not considered to be extended through time.\n",
    "    \"\"\"\n",
    "\n",
    "    def no_self_loops_condition(G):\n",
    "        return not(any([(y,y) in G.edges() for y in G.nodes()]))\n",
    "    return no_self_loops_condition\n",
    "            \n",
    "def create_path_complete_condition(transmit_node_pairs):\n",
    "    \"\"\"\n",
    "    This factory allows us to specify that there are valid directed paths between pairs of nodes.\n",
    "    This returns a function that takes an graph argument (G) \n",
    "    and verifies that for the list of node pairs the graph meets those dependency conditions. \n",
    "    \n",
    "    NB: This is useful for making known indirect dependencies explicit.\n",
    "    \n",
    "    Variables:\n",
    "    node_list is a list of 2-tuples of nodes that will have valid direct paths \n",
    "    from the first of the nodes to the second.\n",
    "    \"\"\"\n",
    "\n",
    "    def path_complete_condition(G):\n",
    "        return all([nx.has_path(G,x,y) for x,y in transmit_node_pairs])\n",
    "    return path_complete_condition\n",
    "\n",
    "def create_no_input_node_condition(node_list):\n",
    "    \"\"\"\n",
    "    This factory allows us to specify that no directed can be directed into a set of nodes.\n",
    "    This returns a function that takes an graph argument (G) and verifies that \n",
    "    none of the nodes in node_list are child nodes. \n",
    "    \n",
    "    NB: This is useful for making interventions explicit over a set of graphs.\n",
    "    \n",
    "    Variables:\n",
    "    node_list is a list of nodes that will have no parents\n",
    "    \"\"\"\n",
    "    \n",
    "    def no_input_node_condition(G):\n",
    "        return all([G.in_degree(y)==0 for y in node_list])\n",
    "    return no_input_node_condition\n",
    "\n",
    "def new_conditional_graph_set(graph_set,condition_list):\n",
    "    \"\"\"\n",
    "    This returns a copy of the old graph_set and a new graph generator which has \n",
    "    the conditions in condition_list applied to it.\n",
    "    \n",
    "    Warning: This function will devour the iterator that you include as the graph_set input, \n",
    "    you need to redeclare the variable as one of the return values of the function.\n",
    "    \n",
    "    Thus a correct use would be:    \n",
    "    a,b = new_conditional_graph_set(a,c)\n",
    "    \n",
    "    The following would not be a correct use:\n",
    "    x,y = new_conditional_graph_set(a,c)\n",
    "    \n",
    "    Variables: \n",
    "    graph_set is a graph-set generator\n",
    "    condition_list is a list of first order functions returning boolean values when passed a graph.\n",
    "    \"\"\"\n",
    "    \n",
    "    try: \n",
    "        condition_list[0]\n",
    "    except TypeError:\n",
    "        raise TypeError(\"\"\"\n",
    "        Subsampling from a graph requires passing in a list of conditions encoded\n",
    "        as first-class functions that accept networkX graphs as an input and return boolean values.\"\"\")\n",
    "    graph_set_newer, graph_set_test = tee(graph_set,2)\n",
    "    def gen():\n",
    "        for G in graph_set_test:\n",
    "            G_test = G.copy()\n",
    "            if all([c(G_test) for c in condition_list]):\n",
    "                yield G_test\n",
    "    return graph_set_newer, gen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "304\n"
     ]
    }
   ],
   "source": [
    "nodes=[\"a\",\"b\",\"c\",\"d\"]\n",
    "known_ancestral_relations = [(\"a\",\"b\"),(\"a\",\"c\"),(\"a\",\"d\")]\n",
    "orphan_nodes = [\"a\"]\n",
    "f1 = create_path_complete_condition(known_ancestral_relations)\n",
    "f2 = create_no_input_node_condition(orphan_nodes)\n",
    "f3 = create_no_self_loops_condition()\n",
    "G = completeDiGraph(nodes)\n",
    "graph_set = conditionalSubgraphs(G, [f1, f2,f3])\n",
    "print(len([graph.edges() for graph in graph_set]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "221\n",
      "304\n"
     ]
    }
   ],
   "source": [
    "\"\"\"This shows an example of updating a graph with a new condtion. \n",
    "\"\"\"\n",
    "nodes=[\"a\",\"b\",\"c\",\"d\"]\n",
    "known_ancestral_relations = [(\"a\",\"b\"),(\"a\",\"c\"),(\"a\",\"d\")]\n",
    "orphan_nodes = [\"a\"]\n",
    "known_ancestral_relations2 = [(\"b\",\"c\")]\n",
    "f1 = create_path_complete_condition(known_ancestral_relations)\n",
    "f2 = create_no_input_node_condition(orphan_nodes)\n",
    "f3 = create_no_self_loops_condition()\n",
    "f1_2 = create_path_complete_condition(known_ancestral_relations2)\n",
    "G = completeDiGraph(nodes)\n",
    "graph_set = conditionalSubgraphs(G, [f1, f2,f3])\n",
    "graph_set, graph_set2 = new_conditional_graph_set(graph_set,[f1_2])\n",
    "print(len([graph.edges() for graph in graph_set2]))\n",
    "print(len([graph.edges() for graph in graph_set]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Note: Your conditions can contradict one another to the point of generating no graphs.\n",
    "\"\"\"\n",
    "\n",
    "nodes=[\"a\",\"b\",\"c\",\"d\"]\n",
    "known_ancestal_relations = [(\"a\",\"b\"),(\"a\",\"c\"),(\"a\",\"d\")]\n",
    "orphan_nodes=[\"a\",\"c\"]\n",
    "f1 = create_path_complete_condition(known_ancestal_relations)\n",
    "f2 = create_no_input_node_condition(orphan_nodes)\n",
    "G = completeDiGraph(nodes)\n",
    "graph_set = conditionalSubgraphs(G, [f1, f2])\n",
    "print(len([graph.edges() for graph in graph_set]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian Network file format and sampler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def sample_from_graph(G,func_dictionary=None,k = 1):\n",
    "    \"\"\"\n",
    "    This is the function that samples from the rich networkX Bayes Net graph using the parameterization specified in the node attributes.\n",
    "    \n",
    "    Variables:\n",
    "    G is the graph being sampled from.\n",
    "    k is the number of samples.\n",
    "    \"\"\"\n",
    "    if func_dictionary == None:\n",
    "        func_dictionary = {\"choice\": np.random.choice}\n",
    "\n",
    "    nodes_dict = G.nodes(data = True)\n",
    "    node_ids = np.array(G.nodes())\n",
    "    state_spaces = [(node[0],node[1][\"state_space\"]) for node in nodes_dict]\n",
    "    orphans = [node for node in nodes_dict if node[1][\"parents\"]==[]]\n",
    "    sample_values = np.empty([len(state_spaces),k],dtype='U20')\n",
    "    sampled_nodes = []\n",
    "\n",
    "    for node in orphans:\n",
    "        ## sample k values for all orphan nodes\n",
    "        samp_func = string_to_sample_function(node[1][\"sample_function\"],func_dictionary)\n",
    "        samp_states = node[1][\"state_space\"]\n",
    "        samp_distribution = node[1][\"distribution\"]\n",
    "        samp_index = G.nodes().index(node[0])\n",
    "        sample_values[samp_index,:]  = samp_func(samp_states,size=[1,k],p=samp_distribution)\n",
    "        sampled_nodes.append(node[0])\n",
    "        \n",
    "    while set(sampled_nodes) < set(G.nodes()):\n",
    "        nodes_to_sample = check_if_parents_filled(G,sampled_nodes)\n",
    "        #nodes_to_sample returns a list of node names that need to be sampled\n",
    "        \n",
    "        for n in nodes_to_sample:\n",
    "            #extracts the indices of the parents of the node to be sampled and their values\n",
    "            parent_indices = [(parent,G.nodes().index(parent)) for parent in G.node[n][\"parents\"]]\n",
    "            parent_vals = [(parent[0],sample_values[parent[1],:]) for parent in parent_indices]\n",
    "            \n",
    "            #extracts sample index\n",
    "            samp_index = G.nodes().index(n)\n",
    "            sample_values[samp_index,:] = conditional_sampling(G,n,parent_vals,func_dictionary,k)\n",
    "            sampled_nodes.append(n)\n",
    "        \n",
    "    return sample_values\n",
    "       \n",
    "    \n",
    "    \n",
    "def check_if_parents_filled(G,sampled_nodes):\n",
    "    \"\"\"\n",
    "    This function will return those nodes who have not yet been sampled, whose parents have been sampled.\n",
    "    Variables:\n",
    "    G is a networkX graph\n",
    "    sampled_nodes are a list of node names\n",
    "    \"\"\"\n",
    "    check_nodes = [x for x in G.nodes() if x not in sampled_nodes]\n",
    "    nodes_to_be_sampled = []\n",
    "    for node in G.nodes(data = True):\n",
    "        if (node[0] in check_nodes) & (node[1][\"parents\"]<=sampled_nodes):\n",
    "            nodes_to_be_sampled.append(node[0])\n",
    "        \n",
    "    if len(nodes_to_be_sampled)==0: \n",
    "        raise RuntimeError(\"You should never be running this when no values are returned\")\n",
    "    return nodes_to_be_sampled\n",
    "\n",
    "def nodeset_query(G,node_set,attrib=[]):\n",
    "    \"\"\"\n",
    "    This is a helper function for querying particular attributes from a node  \n",
    "    Variables:\n",
    "    G is a networkX style graph\n",
    "    node_set is a list of node names that are in G\n",
    "    attrib are a list of attributes associated with the nodes in G\n",
    "    \"\"\"\n",
    "    if len(attrib)==0:\n",
    "        return [node for node in G.nodes(data = True) if node[0] in node_set]\n",
    "    else:\n",
    "        return_val = []\n",
    "        for node in G.nodes(data=True):\n",
    "            if node[0] in node_set:\n",
    "                return_val.append((node[0],{attr:node[1][attr] for attr in attrib}))\n",
    "        return return_val\n",
    "    \n",
    "    \n",
    "def conditional_sampling(G,node,parent_vals,func_dictionary, k = 1):\n",
    "    \"\"\"\n",
    "    This function takes a graph as input, a node to sample from in that graph and a set of values for the parents of that node.\n",
    "    This function should not be consulted for variables without any parents.\n",
    "    Variables: \n",
    "    G is a networkX style graph\n",
    "    node is a node in G\n",
    "    parent_vals are the values of the parents of node realized k times\n",
    "    returns an array of values \n",
    "    \"\"\"\n",
    "    \n",
    "    try: node in G\n",
    "    except KeyError:\n",
    "        print(\"{} is not in graph\".format(n))\n",
    "    \n",
    "    output = np.empty(k,dtype=\"U20\")\n",
    "    for i in np.arange(k):\n",
    "        par_val_list = []\n",
    "        for parent in parent_vals:\n",
    "            par_val_list.append(tuple([parent[0],parent[1][i]]))\n",
    "        samp_distribution = G.node[node][\"distribution\"][tuple(par_val_list)]\n",
    "\n",
    "    \n",
    "        samp_func = string_to_sample_function(G.node[node][\"sample_function\"],func_dictionary)\n",
    "        samp_states = G.node[node][\"state_space\"]\n",
    "#         output.append(samp_func(samp_states,size=[1],p=samp_distribution))\n",
    "        temp_output = samp_func(samp_states,size=1,p=samp_distribution)\n",
    "        output[i] = temp_output[0]\n",
    "    return output\n",
    "\n",
    "def string_to_sample_function(func_name, func_dictionary=None):\n",
    "    \"\"\"\n",
    "    This allows the function to be passed in as a string that is mapped to a first-class function to other methods.\n",
    "    sample_function is a string that maps onto a function in the dictionary defined below.\n",
    "    This takes two arguments a func_dictionary \n",
    "    \"\"\"\n",
    "    if func_dictionary == None:\n",
    "        func_dictionary = {\"choice\": np.random.choice}\n",
    "        \n",
    "    try: func_dictionary[func_name]\n",
    "    except KeyError:\n",
    "        print(\"{} is not a function defined in the dictionary you passed.\".format(func_name))\n",
    "    \n",
    "    return func_dictionary[func_name]\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['dry' 'dry' 'dry' 'dry' 'dry' 'dry' 'dry' 'raining' 'dry' 'dry']\n",
      " ['notWet' 'notWet' 'notWet' 'notWet' 'wet' 'wet' 'notWet' 'wet' 'notWet'\n",
      "  'wet']\n",
      " ['off' 'off' 'off' 'off' 'on' 'on' 'off' 'off' 'off' 'on']]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "dict_of_understanding = {\"choice\": np.random.choice}\n",
    "\n",
    "edge_list = [\n",
    "    (\"sprinkler\",\"grass_wet\"),\n",
    "    (\"rain\",\"sprinkler\"),\n",
    "    (\"rain\",\"grass_wet\")\n",
    "]\n",
    "\n",
    "node_prop_list = [\n",
    "    (\"rain\",\n",
    "     {\"state_space\":(\"raining\",\"dry\"), \"sample_function\": \"choice\",\n",
    "      \"parents\":[], \n",
    "      \"distribution\":[.2,.8]\n",
    "     }),\n",
    "    (\"sprinkler\",\n",
    "     {\"state_space\":(\"on\",\"off\"),\"sample_function\": \"choice\",\n",
    "      \"parents\":[\"rain\"], \n",
    "      \"distribution\":{((\"rain\",\"raining\"),):[.01,.99],\n",
    "                      ((\"rain\",\"dry\"),):[.4,.6]}\n",
    "     }),\n",
    "    (\"grass_wet\",\n",
    "     {\"state_space\":(\"wet\",\"notWet\"),\"sample_function\": \"choice\",\n",
    "      \"parents\":[\"rain\",\"sprinkler\"],\n",
    "      \"distribution\":{((\"rain\",\"raining\"),(\"sprinkler\",\"on\")):[.99,.01],\n",
    "                      ((\"rain\",\"raining\"),(\"sprinkler\",\"off\")):[.8,.2],\n",
    "                      ((\"rain\",\"dry\"),(\"sprinkler\",\"on\")):[.9,.1],\n",
    "                      ((\"rain\",\"dry\"),(\"sprinkler\",\"off\")):[0,1]}\n",
    "\n",
    "     })\n",
    "]\n",
    "\n",
    "func_dictionary = dict_of_understanding\n",
    "k = 10\n",
    "G = nx.DiGraph()\n",
    "G.clear()\n",
    "G.add_edges_from(edge_list)\n",
    "G.add_nodes_from(node_prop_list)\n",
    "test = sample_from_graph(G,func_dictionary,k)\n",
    "print(test)\n",
    "print(\"\\n\")\n",
    "# print(json_graph.adjacency_data(G))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian Network file format and sampler (text minimized for paper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def sample_from_graph(G,f_dict=None,k = 1):\n",
    "    if f_dict == None:\n",
    "        f_dict = {\"choice\": np.random.choice}\n",
    "    n_dict = G.nodes(data = True)\n",
    "    n_ids = np.array(G.nodes())\n",
    "    n_states = [(n[0],n[1][\"state_space\"]) for n in n_dict]\n",
    "    orphans = [n for n in n_dict if n[1][\"parents\"]==[]]\n",
    "    s_values = np.empty([len(n_states),k],dtype='U20')\n",
    "    s_nodes = []\n",
    "    for n in orphans:\n",
    "        samp_f = str_to_f(n[1][\"sample_function\"],\n",
    "            f_dict)\n",
    "        s_states = n[1][\"state_space\"]\n",
    "        s_dist = n[1][\"dist\"]\n",
    "        s_idx = G.nodes().index(n[0])\n",
    "        s_values[s_idx,:]  = samp_f(s_states,\n",
    "            size=[1,k],p=s_dist)\n",
    "        s_nodes.append(n[0])\n",
    "    while set(s_nodes) < set(G.nodes()):\n",
    "        nodes_to_sample = has_full_parents(G,s_nodes)\n",
    "        for n in nodes_to_sample:\n",
    "            par_indices = [(par,G.nodes().index(par)) \n",
    "                for par in G.node[n][\"parents\"]]\n",
    "            par_vals = [(par[0],s_values[par[1],:]) \n",
    "                for par in par_indices]\n",
    "            samp_index = G.nodes().index(n)\n",
    "            s_values[samp_index,:] = cond_samp(G,n,\n",
    "                par_vals,f_dict,k)\n",
    "            s_nodes.append(n)\n",
    "    return s_values\n",
    "\n",
    "def has_full_parents(G,s_n):\n",
    "    check_n = [x for x in G.nodes() if x not in s_n]\n",
    "    nodes_to_be_sampled = []\n",
    "    for n in G.nodes(data = True):\n",
    "        if (n[0] in check_n) & (n[1][\"parents\"]<=s_n):\n",
    "            nodes_to_be_sampled.append(n[0])\n",
    "    if len(nodes_to_be_sampled)==0: \n",
    "        raise RuntimeError(\"A node must be sampled\")\n",
    "    return nodes_to_be_sampled\n",
    "\n",
    "def nodeset_query(G,n_set,n_atr=[]):\n",
    "    if len(n_atr)==0:\n",
    "        return [n for n in G.nodes(data = True) \n",
    "            if n[0] in n_set]\n",
    "    else:\n",
    "        return_val = []\n",
    "        for n in G.nodes(data=True):\n",
    "            if n[0] in node_set:\n",
    "                return_val.append((n[0],\n",
    "                {attr:n[1][attr] for attr in n_atr}))\n",
    "        return return_val\n",
    "\n",
    "\n",
    "def cond_samp(G,n,par_vals,f_dict, k = 1):\n",
    "    try: n in G\n",
    "    except KeyError:\n",
    "        print(\"{} is not in graph\".format(n))\n",
    "    output = np.empty(k,dtype=\"U20\")\n",
    "    for i in np.arange(k):\n",
    "        val_list = []\n",
    "        for p in par_vals:\n",
    "            val_list.append(tuple([p[0],p[1][i]]))\n",
    "        samp_dist = G.node[n][\"dist\"][tuple(val_list)]\n",
    "        samp_f = str_to_f(\n",
    "            G.node[n][\"sample_function\"],f_dict)\n",
    "        samp_states = G.node[n][\"state_space\"]\n",
    "        temp_output = samp_f(samp_states,\n",
    "            size=1,p=samp_dist)\n",
    "        output[i] = temp_output[0]\n",
    "    return output\n",
    "\n",
    "def str_to_f(f_name, f_dict=None):\n",
    "    if f_dict == None:\n",
    "        f_dict = {\"choice\": np.random.choice}\n",
    "    try: f_dict[f_name]\n",
    "    except KeyError:\n",
    "        print(\"{} is not defined.\".format(f_name))\n",
    "    return f_dict[f_name]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['no' 'no' 'no' 'no' 'no' 'no' 'no' 'yes' 'yes' 'yes']\n",
      " ['dry' 'wet' 'dry' 'dry' 'dry' 'wet' 'dry' 'wet' 'wet' 'wet']\n",
      " ['off' 'on' 'off' 'off' 'off' 'on' 'off' 'off' 'off' 'off']]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "dict_of_understanding = {\"choice\": np.random.choice}\n",
    "\n",
    "edge_list = [\n",
    "    (\"sprinkler\",\"grass_wet\"),\n",
    "    (\"rain\",\"sprinkler\"),\n",
    "    (\"rain\",\"grass_wet\")\n",
    "]\n",
    "\n",
    "node_prop_list = [\n",
    "    (\"rain\",{\n",
    "    \"state_space\":(\"yes\",\"no\"), \n",
    "    \"sample_function\": \"choice\",\n",
    "    \"parents\":[], \n",
    "    \"dist\":[.2,.8]}),\n",
    "    (\"sprinkler\",{\n",
    "    \"state_space\":(\"on\",\"off\"),\n",
    "    \"sample_function\": \"choice\",\n",
    "    \"parents\":[\"rain\"], \n",
    "    \"dist\":{((\"rain\",\"yes\"),):[.01,.99],\n",
    "            ((\"rain\",\"no\"),):[.4,.6]}}),\n",
    "    (\"grass_wet\",{\n",
    "    \"state_space\":(\"wet\",\"dry\"),\n",
    "    \"sample_function\": \"choice\",\n",
    "    \"parents\":[\"rain\",\"sprinkler\"],\n",
    "    \"dist\":{\n",
    "        ((\"rain\",\"yes\"),(\"sprinkler\",\"on\")):[.99,.01],\n",
    "        ((\"rain\",\"yes\"),(\"sprinkler\",\"off\")):[.8,.2],\n",
    "        ((\"rain\",\"no\"),(\"sprinkler\",\"on\")):[.9,.1],\n",
    "        ((\"rain\",\"no\"),(\"sprinkler\",\"off\")):[0,1]}})]\n",
    "\n",
    "func_dictionary = dict_of_understanding\n",
    "k = 10\n",
    "G = nx.DiGraph()\n",
    "G.clear()\n",
    "G.add_edges_from(edge_list)\n",
    "G.add_nodes_from(node_prop_list)\n",
    "test = sample_from_graph(G,k=10)\n",
    "# test = sample_from_graph(G,func_dictionary,k)\n",
    "\n",
    "print(test)\n",
    "print(\"\\n\")\n",
    "# print(json_graph.adjacency_data(G))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO: Saving out as valid JSON files, and loading them cleanly in\n",
    "\n",
    "Current problem: tuples are unacceptable as JSON keys. Need to convert them(and only them) to strings. \n",
    "\n",
    "Currently this is not complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from networkx.readwrite import json_graph\n",
    "import datetime as datetime\n",
    "import json\n",
    "\n",
    "def json_filename_utility(inputName, file_format = \".json\"):\n",
    "    if file_format[0]!=\".\":\n",
    "        return str(inputName)+\"_{}\".format(datetime.datetime.today().strftime(\"%Y_%V_%u_%H%M\")) + \".\" + str(file_format)\n",
    "    return str(inputName)+\"_{}\".format(datetime.datetime.today().strftime(\"%Y_%V_%u_%H%M\")) + str(file_format)\n",
    "\n",
    "def json_adj_save(graph,out_file_name=\"\"):\n",
    "    if len(out_file_name)==0:\n",
    "        out_file_name = json_filename_utility(\"graph_data\")\n",
    "    data = json_graph.adjacency_data(graph)\n",
    "    \n",
    "    \n",
    "#     test_data = json.dumps(data)\n",
    "    with open(out_file_name,\"w\") as outfile:\n",
    "        json.dump(data, outfile, ensure_ascii=False)\n",
    "    return\n",
    "\n",
    "\n",
    "def clean_json_adj_load(file_name):\n",
    "    with open(file_name) as d:\n",
    "        json_data = json.load(d)\n",
    "    H = json_graph.adjacency_graph(json_data)\n",
    "    for edge_here in H.edges():\n",
    "        del(H[edge_here[0]][edge_here[1]][\"id\"])\n",
    "    return H\n",
    "\n",
    "def clean_json_adj_loads(json_str):\n",
    "    json_data = json.loads(json_str)\n",
    "    H = json_graph.adjacency_graph(json_data)\n",
    "    for edge_here in H.edges():\n",
    "        del(H[edge_here[0]][edge_here[1]][\"id\"])\n",
    "    return H\n",
    "# new_data = json.dumps(json_graph.adjacency_data(test_graph),  ensure_ascii=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = str(json_graph.adjacency_data(G))\n",
    "y = ast.literal_eval(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Expecting property name enclosed in double quotes: line 1 column 2 (char 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-157-653c0834020b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mclean_json_adj_loads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-29-671ad1b01b16>\u001b[0m in \u001b[0;36mclean_json_adj_loads\u001b[0;34m(json_str)\u001b[0m\n\u001b[1;32m     26\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclean_json_adj_loads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjson_str\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 28\u001b[0;31m     \u001b[0mjson_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjson_str\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     29\u001b[0m     \u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_graph\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madjacency_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjson_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0medge_here\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mH\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0medges\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/json/__init__.py\u001b[0m in \u001b[0;36mloads\u001b[0;34m(s, encoding, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)\u001b[0m\n\u001b[1;32m    316\u001b[0m             \u001b[0mparse_int\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mparse_float\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    317\u001b[0m             parse_constant is None and object_pairs_hook is None and not kw):\n\u001b[0;32m--> 318\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_default_decoder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    320\u001b[0m         \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mJSONDecoder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/json/decoder.py\u001b[0m in \u001b[0;36mdecode\u001b[0;34m(self, s, _w)\u001b[0m\n\u001b[1;32m    341\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m         \"\"\"\n\u001b[0;32m--> 343\u001b[0;31m         \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraw_decode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_w\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m         \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_w\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mend\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/json/decoder.py\u001b[0m in \u001b[0;36mraw_decode\u001b[0;34m(self, s, idx)\u001b[0m\n\u001b[1;32m    357\u001b[0m         \"\"\"\n\u001b[1;32m    358\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 359\u001b[0;31m             \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan_once\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    360\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    361\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merrmsg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Expecting value\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)"
     ]
    }
   ],
   "source": [
    "clean_json_adj_loads(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "{'adjacency': [[],\n",
    "  [{'id': 'grass_wet'}, {'id': 'sprinkler'}],\n",
    "  [{'id': 'grass_wet'}]],\n",
    " 'directed': True,\n",
    " 'graph': [],\n",
    " 'multigraph': False,\n",
    " 'nodes': [{'distribution': {(('rain', 'dry'), ('sprinkler', 'off')): [0, 1],\n",
    "    (('rain', 'dry'), ('sprinkler', 'on')): [0.9, 0.1],\n",
    "    (('rain', 'raining'), ('sprinkler', 'off')): [0.8, 0.2],\n",
    "    (('rain', 'raining'), ('sprinkler', 'on')): [0.99, 0.01]},\n",
    "   'id': 'grass_wet',\n",
    "   'parents': ['rain', 'sprinkler'],\n",
    "   'sample_function': 'choice',\n",
    "   'state_space': ('wet', 'notWet')},\n",
    "  {'distribution': [0.2, 0.8],\n",
    "   'id': 'rain',\n",
    "   'parents': [],\n",
    "   'sample_function': 'choice',\n",
    "   'state_space': ('raining', 'dry')},\n",
    "  {'distribution': {(('rain', 'dry'),): [0.4, 0.6],\n",
    "    (('rain', 'raining'),): [0.01, 0.99]},\n",
    "   'id': 'sprinkler',\n",
    "   'parents': ['rain'],\n",
    "   'sample_function': 'choice',\n",
    "   'state_space': ('on', 'off')}]}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# json_adj_save(G)\n",
    "data = json_graph.adjacency_data(G)\n",
    "def check_type_of_keys(dictionary_passed):\n",
    "    newdict = dict()\n",
    "    for key,value in dictionary_passed.items():\n",
    "        if type(key) is tuple:\n",
    "            newdict[str(key)] = value\n",
    "            newdict[str(key)+\"_converted\"]=True\n",
    "        else:\n",
    "#             print(type(key),\"key\",key)\n",
    "            newdict[key]=value\n",
    "            newdict[str(key)+\"_converted\"]=False\n",
    "        \n",
    "        if type(value) is list:\n",
    "            for element in value:\n",
    "#                 print(type(element),element,\" element\")\n",
    "                if type(element) is dict:\n",
    "                    newdict[key] = check_type_of_keys(element)\n",
    "#                     print(\"yup\")\n",
    "#         print(type(value),value, \"value\")\n",
    "        if type(value) is dict:\n",
    "            newdict[key] = check_type_of_keys(value)\n",
    "#             print(\"yes\")\n",
    "#         print(type(value),value)\n",
    "        \n",
    "    return newdict\n",
    "\n",
    "# print(data)\n",
    "# newdict=dict()\n",
    "# for key,value in data.items():\n",
    "#     if type(key) is tuple:\n",
    "#         newdict[str(key)]= value\n",
    "#         newdict[str(key)+\"_converted\"]=True\n",
    "#     else:\n",
    "#         newdict[key]=value\n",
    "#         newdict[str(key)+\"_converted\"]=False\n",
    "#     if type(value) is dict:\n",
    "#         for key2,value2 in value.items():\n",
    "#             if type(key2) is tuple:\n",
    "#                 newdict[str(key2)]= value2\n",
    "#                 newdict[str(key2)+\"_converted\"]=True\n",
    "#             elif type(value2) is dict:\n",
    "#                 for key3,value3 in value2.items():\n",
    "#                     if type(key3) is tuple:\n",
    "#                         newdict[str(key3)]= value3\n",
    "#                         newdict[str(key3)+\"_converted\"]=True\n",
    "#                     elif: type(\n",
    "#                     else:\n",
    "#                         newdict[key3]=value3\n",
    "#                         newdict[str(key3)+\"_converted\"]=False\n",
    "#             else:\n",
    "#                 newdict[key2]=value\n",
    "#                 newdict[str(key2)+\"_converted\"]=False\n",
    "#     else:\n",
    "#         newdict[key]=value\n",
    "#         newdict[str(key)+\"_converted\"]=False\n",
    "# print(check_type_of_keys(data))\n",
    "with open(\"test_file3\",\"w\") as outfile:\n",
    "    json.dump(check_type_of_keys(data), outfile, ensure_ascii=False)\n",
    "\n",
    "# with open(\"test_file2\",\"w\") as outfile:\n",
    "#     json.dump(data, outfile, ensure_ascii=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"(('rain', 'raining'),)_converted\": True, \"(('rain', 'raining'),)\": [0.01, 0.99], \"(('rain', 'dry'),)\": [0.4, 0.6], \"(('rain', 'dry'),)_converted\": True}\n",
      "(('rain', 'raining'),)_converted\n",
      "{\"(('rain', 'raining'),)\": [0.01, 0.99], \"(('rain', 'dry'),)\": [0.4, 0.6], \"(('rain', 'dry'),)_converted\": True}\n",
      "\n",
      "\n",
      "(('rain', 'raining'),)\n",
      "\n",
      "\n",
      "{(('rain', 'raining'),): True, \"(('rain', 'raining'),)\": [0.01, 0.99], \"(('rain', 'dry'),)\": [0.4, 0.6], \"(('rain', 'dry'),)_converted\": True}\n",
      "(('rain', 'dry'),)_converted\n",
      "{(('rain', 'raining'),): True, \"(('rain', 'raining'),)\": [0.01, 0.99], \"(('rain', 'dry'),)\": [0.4, 0.6]}\n",
      "\n",
      "\n",
      "(('rain', 'dry'),)\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "({'adjacency': [[],\n",
       "   [{'id': 'grass_wet'}, {'id': 'sprinkler'}],\n",
       "   [{'id': 'grass_wet'}]],\n",
       "  'directed': True,\n",
       "  'graph': [],\n",
       "  'multigraph': False,\n",
       "  'nodes': {'distribution': {(('rain', 'raining'),): True,\n",
       "    \"(('rain', 'raining'),)\": [0.01, 0.99],\n",
       "    \"(('rain', 'dry'),)\": [0.4, 0.6],\n",
       "    (('rain', 'dry'),): True},\n",
       "   'id': 'sprinkler',\n",
       "   'parents': ['rain'],\n",
       "   'sample_function': 'choice',\n",
       "   'state_space': ['on', 'off']}},\n",
       " {'adjacency': [[],\n",
       "   [{'id': 'grass_wet'}, {'id': 'sprinkler'}],\n",
       "   [{'id': 'grass_wet'}]],\n",
       "  'directed': True,\n",
       "  'graph': [],\n",
       "  'multigraph': False,\n",
       "  'nodes': {'distribution': {(('rain', 'raining'),): True,\n",
       "    \"(('rain', 'raining'),)\": [0.01, 0.99],\n",
       "    \"(('rain', 'dry'),)\": [0.4, 0.6],\n",
       "    (('rain', 'dry'),): True},\n",
       "   'id': 'sprinkler',\n",
       "   'parents': ['rain'],\n",
       "   'sample_function': 'choice',\n",
       "   'state_space': ['on', 'off']}})"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import ast\n",
    "\n",
    "def undo_conversion(input_dict):\n",
    "#     print([(x,input_dict[x]) for x in input_dict if x.endswith(\"_converted\")])\n",
    "    not_converted_keys = [x for x in input_dict if x.endswith(\"_converted\") and not input_dict[x]]\n",
    "    for key in not_converted_keys:\n",
    "        input_dict.pop(key)\n",
    "#     print([(x,input_dict[x]) for x in input_dict if x.endswith(\"_converted\")])\n",
    "    converted_keys = [x for x in input_dict if x.endswith(\"_converted\") and input_dict[x]]\n",
    "#     print([(x,input_dict[x]) for x in input_dict if x.endswith(\"_converted\")])\n",
    "    for key in converted_keys:\n",
    "        print(input_dict)\n",
    "        holding_val = input_dict.pop(key)\n",
    "        print(key)\n",
    "        print(input_dict)\n",
    "        second_key = strip_end(key,\"_converted\")\n",
    "        print(\"\\n\\n\"+second_key+\"\\n\\n\")\n",
    "        input_dict[ast.literal_eval(second_key)]= holding_val\n",
    "    \n",
    "    for key, value in input_dict.items():\n",
    "        if type(value) is dict:\n",
    "            input_dict[key] = undo_conversion(value)\n",
    "    return input_dict\n",
    "\n",
    "def strip_end(text, suffix):\n",
    "    # thanks to http://stackoverflow.com/a/1038999/1816995\n",
    "#     print(text)\n",
    "    if not text.endswith(suffix):\n",
    "#         print(text)\n",
    "        return text\n",
    "#     print(text[:len(text)-len(suffix)])\n",
    "    return text[:len(text)-len(suffix)]\n",
    "        \n",
    "\n",
    "    \n",
    "with open(\"test_file1\",\"r\") as outfile:\n",
    "    x = json.load(outfile)\n",
    "x2 = undo_conversion(x)\n",
    "# json_graph.adjacency_graph(x)\n",
    "x,x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'str' object has no attribute 'copy'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-87-9219f1849ad7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mclean_json_adj_load\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"test_file1\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-29-671ad1b01b16>\u001b[0m in \u001b[0;36mclean_json_adj_load\u001b[0;34m(file_name)\u001b[0m\n\u001b[1;32m     20\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile_name\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0mjson_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m     \u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_graph\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madjacency_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjson_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     23\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0medge_here\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mH\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0medges\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m         \u001b[0;32mdel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mH\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0medge_here\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0medge_here\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"id\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.4/site-packages/networkx/readwrite/json_graph/adjacency.py\u001b[0m in \u001b[0;36madjacency_graph\u001b[0;34m(data, directed, multigraph, attrs)\u001b[0m\n\u001b[1;32m    143\u001b[0m     \u001b[0mmapping\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    144\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0md\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'nodes'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 145\u001b[0;31m         \u001b[0mnode_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    146\u001b[0m         \u001b[0mnode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnode_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    147\u001b[0m         \u001b[0mmapping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'str' object has no attribute 'copy'"
     ]
    }
   ],
   "source": [
    "clean_json_adj_load(\"test_file1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute 'items'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-69-3df6023fffb0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"nodes\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"distribution\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'items'"
     ]
    }
   ],
   "source": [
    "for key,value in data[\"nodes\"][1][\"distribution\"].items():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(1, 2)'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str((1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"\"\"Next Steps (part 1)— Build a hybrid discrete continuous system\n",
    "\"\"\"\n",
    "edge_list = [\n",
    "    (\"sprinkler\",\"grass_wet\", {\"state_space_map\": ((\"on\",\"off\"),(0.0,))}),\n",
    "    (\"rain\",\"sprinkler\", {\"state_space_map\": ((0.0,),(\"on\",\"off\"))}),\n",
    "    (\"rain\",\"grass_wet\", {\"state_space_map\":((0.0,),(0.0,))})\n",
    "]\n",
    "\n",
    "node_prop_list = [\n",
    "    (\"rain\",\n",
    "     {\"state_space\":(0.0,), \"sample_function\": \"\",#function with positive real number output\n",
    "      \"parents\":[], \n",
    "      \"distribution\": {\n",
    "                # insert distribution with real number output value\n",
    "            }\n",
    "     }),\n",
    "    (\"sprinkler\",\n",
    "     {\"state_space\":(\"on\",\"off\"),\"sample_function\": \"\"#discrete output,\n",
    "      \"parents\":[\"rain\"], \n",
    "      \"distribution\":{\n",
    "                # Insert distribution with real number input and discrete choice output\n",
    "            }\n",
    "     }),\n",
    "    (\"grass_wet\",\n",
    "     {\"state_space\":(0.0,),\"sample_function\": \"\",#real number function type\n",
    "      \"parents\":[\"rain\",\"sprinkler\"],\n",
    "      \"distribution\":{\n",
    "                #Insert distribution with real number and discrete choice input and real number output\n",
    "            }\n",
    "     })\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Next Steps(part 2)**: \n",
    "1. Transforming Networks from edge parameterization to node parameterization and vice versa.\n",
    "2. Expand to the second json format to include distribution functions defined as lambda functions to be slightly more general."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Separating Data, Parameterization and Structure\n",
    "\n",
    "One of the problems with the above approach to sampling is that there is an implicit trial structure that the sampling relies on to govern its steps. This is embedded every time you see a `for` loop that iterates through `k` samples.\n",
    "\n",
    "This is fine for discrete time steps where you have a sample from all nodes for each of those time steps, but when generalizing to continuous time, where there is no predefined trial structure."
   ]
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}