making variational inference work

1 files changed, 19 insertions, 19 deletions

diff --git a/simulation/active_blocks.py b/simulation/active_blocks.py
index e3924c6..7aa1afb 100644
--- a/simulation/active_blocks.py
+++ b/simulation/active_blocks.py
@@ -33,7 +33,7 @@ class LearnedDataset(fuel.datasets.Dataset):
         i = 0
         while i < request:
             x_tmp, s_tmp = mn.build_cascade_list(
-                mn.simulate_cascades(self.n_cascades, graph, self.source),
+                mn.simulate_cascades(self.n_cascades, self.graph, self.source),
                 collapse=True
             )
             x_obs[i:i + len(x_tmp)] = x_tmp[:request - i]
@@ -60,11 +60,9 @@ class ActiveLearning(blocks.extensions.SimpleExtension):
 
 
 class ShuffledBatchesScheme(fuel.schemes.ShuffledScheme):
-    """
-    Iteration scheme over finite dataset:
+    """Iteration scheme over finite dataset:
         -shuffles batches but not within batch
-        -arguments: dataset_size (int) ; batch_size (int)
-    """
+        -arguments: dataset_size (int) ; batch_size (int)"""
     def get_request_iterator(self):
         indices = list(self.indices)  # self.indices = xrange(dataset_size)
         start = np.random.randint(self.batch_size)
@@ -80,12 +78,8 @@ class ShuffledBatchesScheme(fuel.schemes.ShuffledScheme):
 
 
 def create_mle_model(graph):
-    """
-    return cascade likelihood theano computation graph
-    """
+    """return cascade likelihood theano computation graph"""
     n_nodes = len(graph)
-    g_shared = theano.shared(value=graph, name='graph')
-
     x = tsr.matrix(name='x', dtype='int8')
     s = tsr.matrix(name='s', dtype='int8')
     params = theano.shared(
@@ -100,12 +94,19 @@ def create_mle_model(graph):
     lkl_mle = lkl_pos + lkl_neg
     lkl_mle.name = 'cost'
 
+    return x, s, params, lkl_mle
+
+
+def rmse_error(graph, params):
+    n_nodes = len(graph)
+    g_shared = theano.shared(value=graph, name='graph')
     diff = (g_shared - params) ** 2
     subarray = tsr.arange(g_shared.shape[0])
     tsr.set_subtensor(diff[subarray, subarray], 0)
     rmse = tsr.sum(diff) / (n_nodes ** 2)
     rmse.name = 'rmse'
-    return x, s, params, lkl_mle, rmse
+    g_shared.name = 'graph'
+    return rmse, g_shared
 
 
 def create_fixed_data_stream(n_cascades, graph, batch_size, shuffle=True):
@@ -137,27 +138,26 @@ def create_learned_data_stream(graph, batch_size):
 
 if __name__ == "__main__":
     batch_size = 1000
-    #graph = mn.create_random_graph(n_nodes=1000)
     graph = mn.create_star(1000)
     print('GRAPH:\n', graph, '\n-------------\n')
 
-    x, s, params, cost, rmse = create_mle_model(graph)
+    x, s, params, cost = create_mle_model(graph)
+    rmse, g_shared = rmse_error(graph, params)
 
     alg = blocks.algorithms.GradientDescent(
        cost=-cost, parameters=[params], step_rule=blocks.algorithms.AdaDelta()
     )
     data_stream = create_learned_data_stream(graph, batch_size)
-    #n_cascades = 10000
-    #data_stream = create_fixed_data_stream(n_cascades, graph, batch_size,
-    #        shuffle=False)
     loop = blocks.main_loop.MainLoop(
         alg, data_stream,
         extensions=[
             blocks.extensions.FinishAfter(after_n_batches = 10**4),
             blocks.extensions.monitoring.TrainingDataMonitoring([cost, params,
-                rmse], after_batch=True),
-            blocks.extensions.Printing(every_n_batches = 10)#,
-            #ActiveLearning(data_stream.dataset)
+                rmse, g_shared], after_batch=True),
+            blocks.extensions.Printing(every_n_batches = 10),
+            ActiveLearning(data_stream.dataset),
+            blocks.extras.extensions.Plot('graph rmse', channels=[],
+                                          every_n_batches = 10)
         ]
     )
     loop.run()