Big code cleanup

1 files changed, 20 insertions, 30 deletions

diff --git a/simulation/active_blocks.py b/simulation/active_blocks.py
index 569cb6c..a1f6e76 100644
--- a/simulation/active_blocks.py
+++ b/simulation/active_blocks.py
@@ -1,11 +1,12 @@
-import main as mn
+import utils
 import theano
 from theano import tensor as tsr
 import blocks
-import blocks.algorithms, blocks.main_loop, blocks.extensions.monitoring
+from blocks import algorithms, main_loop
+import blocks.extensions as be
+import blocks.extensions.monitoring as bm
 import picklable_itertools
 import numpy as np
-from six.moves import range
 import fuel
 import fuel.datasets
 import collections
@@ -19,28 +20,16 @@ class LearnedDataset(fuel.datasets.Dataset):
     """
     provides_sources = ('x', 's')
 
-    def __init__(self, node_p, graph, source=mn.var_source, **kwargs):
+    def __init__(self, node_p, graph, **kwargs):
         super(LearnedDataset, self).__init__(**kwargs)
         self.node_p = node_p
         self.graph = graph
-        self.n_cascades = 1  # nbr of cascades of total size approx = request
-        self.source = lambda graph, t : source(graph, t, self.node_p)
+        self.source = lambda graph: utils.random_source(graph, self.node_p)
 
     def get_data(self, state=None, request=None):
-        floatX = 'int8'
-        x_obs = np.empty((request, len(self.graph)), dtype=floatX)
-        s_obs = np.empty((request, len(self.graph)), dtype=floatX)
-        i = 0
-        while i < request:
-            x_tmp, s_tmp = mn.build_cascade_list(
-                mn.simulate_cascades(self.n_cascades, self.graph, self.source),
-                collapse=True
-            )
-            x_obs[i:i + len(x_tmp)] = x_tmp[:request - i]
-            s_obs[i:i + len(x_tmp)] = s_tmp[:request - i]
-            i += len(x_tmp)
-            self.n_cascades += 1  # learn optimal nbr in loop
-        self.n_cascades = max(1, self.n_cascades - 2)
+        # floatX = 'int8'
+        x_obs, s_obs = utils.simulate_cascades(request, self.graph, self.source)
+
         return (x_obs, s_obs)
 
 
@@ -115,8 +104,9 @@ def create_fixed_data_stream(n_cascades, graph, batch_size, shuffle=True):
         -shuffle (bool): shuffle minibatches but not within minibatch, else
         sequential (non-shuffled) batches are used
     """
-    cascades = mn.build_cascade_list(mn.simulate_cascades(n_cascades, graph),
-                                     collapse=True)
+    cascades = utils.build_cascade_list(
+        utils.simulate_cascades(n_cascades, graph),
+        collapse=True)
     x_obs, s_obs = cascades[0], cascades[1]
     data_set = fuel.datasets.base.IndexableDataset(collections.OrderedDict(
         [('x', x_obs), ('s', s_obs)]
@@ -138,23 +128,23 @@ def create_learned_data_stream(graph, batch_size):
 
 if __name__ == "__main__":
     batch_size = 1000
-    graph = mn.create_star(1000)
+    graph = utils.create_wheel(1000)
     print('GRAPH:\n', graph, '\n-------------\n')
 
     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()
+    alg = algorithms.GradientDescent(
+        cost=-cost, parameters=[params], step_rule=blocks.algorithms.AdaDelta()
     )
     data_stream = create_learned_data_stream(graph, batch_size)
-    loop = blocks.main_loop.MainLoop(
+    loop = main_loop.MainLoop(
         alg, data_stream,
         extensions=[
-            blocks.extensions.FinishAfter(after_n_batches = 10**4),
-            blocks.extensions.monitoring.TrainingDataMonitoring([cost, params,
-                rmse, g_shared], after_batch=True),
-            blocks.extensions.Printing(every_n_batches = 10),
+            be.FinishAfter(after_n_batches=10**4),
+            bm.TrainingDataMonitoring([cost, params,
+                                       rmse, g_shared], after_batch=True),
+            be.Printing(every_n_batches=10),
             ActiveLearning(data_stream.dataset),
         ]
     )