diff options
| -rw-r--r-- | simulation/mle_blocks.py | 59 | ||||
| -rw-r--r-- | simulation/utils_blocks.py (renamed from simulation/active_blocks.py) | 39 | ||||
| -rw-r--r-- | simulation/vi_blocks.py | 47 |
3 files changed, 88 insertions, 57 deletions
diff --git a/simulation/mle_blocks.py b/simulation/mle_blocks.py new file mode 100644 index 0000000..89aaf2e --- /dev/null +++ b/simulation/mle_blocks.py @@ -0,0 +1,59 @@ +import utils +import utils_blocks as ub +import theano +from theano import tensor as tsr +from blocks import algorithms, main_loop +import blocks.extensions as be +import blocks.extensions.monitoring as bm +import numpy as np + + +def create_mle_model(graph): + """return cascade likelihood theano computation graph""" + n_nodes = len(graph) + x = tsr.matrix(name='x', dtype='int8') + s = tsr.matrix(name='s', dtype='int8') + params = theano.shared( + .5 + .01 * + np.random.normal(size=(n_nodes, n_nodes)).astype(theano.config.floatX), + name='params' + ) + y = tsr.maximum(tsr.dot(x, params), 1e-5) + infect = tsr.log(1. - tsr.exp(-y[0:-1])) + lkl_pos = tsr.sum(infect * (x[1:] & s[1:])) + lkl_neg = tsr.sum(-y[0:-1] * (~x[1:] & s[1:])) + lkl_mle = lkl_pos + lkl_neg + lkl_mle.name = 'cost' + + return x, s, params, lkl_mle + + +if __name__ == "__main__": + batch_size = 100 + n_obs = 100000 + graph = utils.create_wheel(100) + + print('GRAPH:\n', graph, '\n-------------\n') + + g_shared = theano.shared(value=graph, name='graph') + x, s, params, cost = create_mle_model(graph) + rmse = ub.rmse_error(g_shared, params) + error = ub.relative_error(g_shared, params) + + alg = algorithms.GradientDescent( + cost=-cost, parameters=[params], step_rule=algorithms.AdaDelta() + ) + data_stream = ub.dynamic_data_stream(graph, batch_size) + # data_stream = ub.fixed_data_stream(n_obs, graph, batch_size) + loop = main_loop.MainLoop( + alg, data_stream, + extensions=[ + be.FinishAfter(after_n_batches=10**3), + bm.TrainingDataMonitoring([cost, params, + rmse, error], every_n_batches=10), + be.Printing(every_n_batches=10), + ub.JSONDump("log.json", every_n_batches=10), + ub.ActiveLearning(data_stream.dataset), + ], + ) + loop.run() diff --git a/simulation/active_blocks.py b/simulation/utils_blocks.py index be1fc3d..0d30786 100644 --- a/simulation/active_blocks.py +++ b/simulation/utils_blocks.py @@ -1,16 +1,11 @@ -import utils -import theano from theano import tensor as tsr -import blocks -from blocks import algorithms, main_loop +import fuel.datasets import blocks.extensions as be -import blocks.extensions.monitoring as bm import picklable_itertools import numpy as np -import fuel -import fuel.datasets from json import dumps import collections +import utils class LearnedDataset(fuel.datasets.Dataset): @@ -31,7 +26,7 @@ class LearnedDataset(fuel.datasets.Dataset): return utils.simulate_cascades(request, self.graph, self.source) -class ActiveLearning(blocks.extensions.SimpleExtension): +class ActiveLearning(be.SimpleExtension): """ Extension which updates the node_p array passed to the get_data method of LearnedDataset @@ -48,7 +43,7 @@ class ActiveLearning(blocks.extensions.SimpleExtension): -class JSONDump(blocks.extensions.SimpleExtension): +class JSONDump(be.SimpleExtension): """Dump a JSON-serialized version of the log to a file.""" def __init__(self, filename, **kwargs): @@ -84,26 +79,6 @@ class ShuffledBatchesScheme(fuel.schemes.ShuffledScheme): return iter(batches[np.random.permutation(len(batches))]) -def create_mle_model(graph): - """return cascade likelihood theano computation graph""" - n_nodes = len(graph) - x = tsr.matrix(name='x', dtype='int8') - s = tsr.matrix(name='s', dtype='int8') - params = theano.shared( - .5 + .01 * - np.random.normal(size=(n_nodes, n_nodes)).astype(theano.config.floatX), - name='params' - ) - y = tsr.maximum(tsr.dot(x, params), 1e-5) - infect = tsr.log(1. - tsr.exp(-y[0:-1])) - lkl_pos = tsr.sum(infect * (x[1:] & s[1:])) - lkl_neg = tsr.sum(-y[0:-1] * (~x[1:] & s[1:])) - lkl_mle = lkl_pos + lkl_neg - lkl_mle.name = 'cost' - - return x, s, params, lkl_mle - - def rmse_error(graph, params): n_nodes = graph.shape[0] diff = (graph - params) ** 2 @@ -116,7 +91,7 @@ def rmse_error(graph, params): def relative_error(graph, params): n_nodes = graph.shape[0] - diff = abs(g_shared - params) + diff = abs(graph - params) subarray = tsr.arange(n_nodes) tsr.set_subtensor(diff[subarray, subarray], 0) error = tsr.sum(tsr.switch(tsr.eq(graph, 0.), 0., diff / graph)) / n_nodes @@ -124,7 +99,7 @@ def relative_error(graph, params): return error -def create_fixed_data_stream(n_obs, graph, batch_size, shuffle=True): +def fixed_data_stream(n_obs, graph, batch_size, shuffle=True): """ creates a datastream for a fixed (not learned) dataset: -shuffle (bool): shuffle minibatches but not within minibatch, else @@ -141,7 +116,7 @@ def create_fixed_data_stream(n_obs, graph, batch_size, shuffle=True): return fuel.streams.DataStream(dataset=data_set, iteration_scheme=scheme) -def create_learned_data_stream(graph, batch_size): +def dynamic_data_stream(graph, batch_size): node_p = np.ones(len(graph)) / len(graph) data_set = LearnedDataset(node_p, graph) scheme = fuel.schemes.ConstantScheme(batch_size) diff --git a/simulation/vi_blocks.py b/simulation/vi_blocks.py index 84e637f..1177979 100644 --- a/simulation/vi_blocks.py +++ b/simulation/vi_blocks.py @@ -1,17 +1,15 @@ -import main as mn +import utils +import utils_blocks as ub 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 theano.tensor.shared_randomstreams import numpy as np -from six.moves import range -import fuel -import fuel.datasets -import active_blocks as ab -class ClippedParams(blocks.algorithms.StepRule): +class ClippedParams(algorithms.StepRule): """A rule to maintain parameters within a specified range""" def __init__(self, min_value, max_value): self.min_value = min_value @@ -38,8 +36,8 @@ def create_vi_model(n_nodes, n_samp=100): sig0 = theano.shared(value=aux(.5, .1), name='sig0') srng = tsr.shared_randomstreams.RandomStreams(seed=123) - theta = srng.normal((n_samp, n_nodes, n_nodes)) * sig[None, :, :] + mu[None, - :, :] + theta = (srng.normal((n_samp, n_nodes, n_nodes)) * sig[None, :, :] + + mu[None, :, :]) y = tsr.maximum(tsr.dot(x, theta), 1e-3) infect = tsr.log(1. - tsr.exp(-y[0:-1])).dimshuffle(1, 0, 2) lkl_pos = tsr.sum(infect * (x[1:] & s[1:])) / n_samp @@ -56,28 +54,27 @@ if __name__ == "__main__": #n_cascades = 10000 batch_size = 10 n_samples = 50 - graph = mn.create_random_graph(n_nodes=4) + graph = utils.create_random_graph(n_nodes=4) print('GRAPH:\n', graph, '\n-------------\n') x, s, mu, sig, cost = create_vi_model(len(graph), n_samples) - rmse, g_shared = ab.rmse_error(graph, mu) + rmse = ub.rmse_error(graph, mu) - step_rules= blocks.algorithms.CompositeRule([blocks.algorithms.AdaDelta(), - ClippedParams(1e-3, 1 - 1e-3)]) + step_rules = algorithms.CompositeRule([algorithms.AdaDelta(), + ClippedParams(1e-3, 1 - 1e-3)]) - alg = blocks.algorithms.GradientDescent(cost=cost, parameters=[mu, sig], - step_rule=step_rules) - #data_stream = ab.create_fixed_data_stream(n_cascades, graph, batch_size, - # shuffle=False) - data_stream = ab.create_learned_data_stream(graph, batch_size) - loop = blocks.main_loop.MainLoop( + alg = algorithms.GradientDescent(cost=cost, parameters=[mu, sig], + step_rule=step_rules) + data_stream = ub.fixed_data_stream(n_cascades, graph, batch_size, + shuffle=False) + # data_stream = ub.dynamic_data_stream(graph, batch_size) + loop = main_loop.MainLoop( alg, data_stream, extensions=[ - blocks.extensions.FinishAfter(after_n_batches = 10**4), - blocks.extensions.monitoring.TrainingDataMonitoring([cost, mu, sig, - rmse, g_shared], after_batch=True), - blocks.extensions.Printing(every_n_batches = 100, - after_epoch=False), + be.FinishAfter(after_n_batches=10**4), + bm.TrainingDataMonitoring([cost, mu, sig, rmse], + every_n_batches=10), + be.Printing(every_n_batches=100, after_epoch=False), ] ) loop.run() |