def test_add_unresolved_components_distribution(self):
v = mfc.Variable()
m = mfc.Variable()
f = Normal.define_variable(mean=m, variance=v)
component_set = set((v, m, f))
self.fg.f = f
self.assertTrue(component_set <= set(self.fg.components_graph.nodes().keys()),
"Variables are all added to _components_graph {} {}".format(component_set, self.fg.components_graph.nodes().keys()))
self.assertTrue(set((v.uuid, m.uuid, f.uuid)) <= self.fg.components.keys(), "Variable is added to _components dict. {} {}".format(v.uuid, self.fg.components))
def test_replicate_variable_with_variable_shape(self):
m = mf.models.Model(verbose=False)
y = mfc.Variable()
m.x = mfc.Variable(shape=(y, 1))
var_map = {}
def func(component):
return 'recursive', 'recursive'
x2 = m.x.replicate(var_map=var_map, replication_function=func)
self.assertTrue(x2.uuid == m.x.uuid)
self.assertTrue(x2.shape == m.x.shape, (x2.shape, m.x.shape))
self.assertTrue(y in m)
def make_bnn_model(self, net):
component_set = set()
m = mf.models.Model(verbose=False)
m.N = mfc.Variable()
m.f = MXFusionGluonFunction(net, num_outputs=1)
m.x = mfc.Variable(shape=(m.N,))
m.r = m.f(m.x)
for k, v in m.r.factor.parameters.items():
if k.endswith('_weight') or k.endswith('_bias'):
d = mf.components.distributions.Normal(mean=mx.nd.array([0]), variance=mx.nd.array([1e6]))
v.set_prior(d)
component_set.union(set([v,d]))
m.y = mf.components.distributions.Categorical.define_variable(log_prob=m.r, num_classes=2, normalization=True, one_hot_encoding=False)
component_set.union(set([m.N, m.f, m.x, m.r, m.y]))
return m, component_set
def test_assignment_with_variable_success(self):
v = mfc.Variable()
self.fg.v = v
self.assertTrue(v in self.fg.components_graph.nodes(),
"Variable is added to _components_graph.")
self.assertTrue(v.uuid in self.fg.components,
"Variable is added to _components dict.")
def test_replicate_simple_model(self):
m = mf.models.Model(verbose=False)
m.x = mfc.Variable(shape=(2,))
m.x_mean = mfc.Variable(value=mx.nd.array([0, 1]), shape=(2,))
m.x_var = mfc.Variable(value=mx.nd.array([1e6]))
d = mf.components.distributions.Normal(mean=m.x_mean, variance=m.x_var)
m.x.set_prior(d)
m2 = m.clone()
# compare m and m2 components and such for exactness.
self.assertTrue(set([v.uuid for v in m.components.values()]) ==
set([v.uuid for v in m2.components.values()]))
self.assertTrue(all([v in m.components for v in m2.components]), (set(m2.components) - set(m.components)))
self.assertTrue(all([v in m2.components for v in m.components]), (set(m.components) - set(m2.components)))
self.assertTrue(all([m.x.shape == m2.x.shape,
m.x_mean.shape == m2.x_mean.shape,
m.x_var.shape == m2.x_var.shape]))
def test_remove_variable_success(self):
v = mfc.Variable()
self.fg.v = v
self.assertTrue(v in self.fg.components_graph.nodes(), "Variable is added to _components_graph.")
self.assertTrue(v.uuid in self.fg.components, "Variable is added to _components dict.")
self.fg.remove_component(v)
self.assertFalse(v in self.fg.components_graph.nodes(), "Variable is removed from _components_graph.")
self.assertFalse(v.uuid in self.fg.components, "Variable is removed from _components dict.")
def test_same_variable_as_multiple_inputs_to_factor_not_in_graph(self):
x = mfc.Variable()
y = mf.components.distributions.Normal.define_variable(mean=x, variance=x)
self.assertTrue(set([v for _, v in y.factor.predecessors]) == set([x]))
self.assertTrue(set([v for _, v in x.successors]) == set([y.factor]))
self.assertTrue(len(y.factor.predecessors) == 2)
self.assertTrue(len(x.successors) == 2)
def test_replicate_variable(self):
m = mf.models.Model(verbose=False)
m.x = mfc.Variable()
def func(component):
return 'recursive', 'recursive'
x2 = m.x.replicate(replication_function=func)
self.assertTrue(x2.uuid == m.x.uuid)
def test_replicate_factor_only_self(self):
m = mf.models.Model(verbose=False)
m.x = mfc.Variable()
d = mf.components.distributions.Normal(mean=mx.nd.array([0]), variance=mx.nd.array([1e6]))
m.x.set_prior(d)
def func(component):
return 'recursive', 'recursive'
x2 = m.x.replicate(replication_function=func)
self.assertTrue(x2.factor is not None)
def test_same_variable_as_multiple_inputs_to_factor_in_graph(self):
fg = mf.models.Model()
fg.x = mfc.Variable()
fg.y = mf.components.distributions.Normal.define_variable(mean=fg.x, variance=fg.x)
self.assertTrue(set([v for _, v in fg.y.factor.predecessors]) == set([fg.x]))
self.assertTrue(set([v for _, v in fg.x.successors]) == set([fg.y.factor]))
self.assertTrue(len(fg.y.factor.predecessors) == 2)
self.assertTrue(len(fg.x.successors) == 2)
def test_set_prior_after_factor_attach(self):
fg = mf.models.Model()
d = mf.components.distributions.Normal(mean=mx.nd.array([1e2]), variance=mx.nd.array([1e6]))
fg.d = d
x = mfc.Variable()
x.set_prior(d)
self.assertTrue(set([v for _, v in d.successors]) == set([x]))
self.assertTrue(set([v for _, v in x.predecessors]) == set([d]))
self.assertTrue(x.graph == d.graph and d.graph == fg.components_graph)
def test_add_unresolved_components_function(self):
f = MXFusionGluonFunction(self.basic_net, num_outputs=1)
x = mfc.Variable()
y = f(x)
component_set = set((x, y))
self.fg.y = y
self.assertTrue(component_set <= set(self.fg.components_graph.nodes().keys()),
"Variables are all added to _components_graph {} {}".format(component_set, self.fg.components_graph.nodes().keys()))
self.assertTrue(set(map(lambda x: x.uuid, component_set)) <= self.fg.components.keys(), "Variable is added to _components dict. {} {}".format(set(map(lambda x: x.uuid, component_set)), self.fg.components.keys()))
self.assertTrue(len(self.fg.components_graph.nodes().keys()) == 5, "There should be variables for the block parameters and a function evaluation totally 5 nodes in the graph but there were only {} in {}".format(len(self.fg.components_graph.nodes().keys()), self.fg.components_graph.nodes().keys()))
def test_replicate_function_only_self(self):
self.D = 10
self.net = nn.HybridSequential()
with self.net.name_scope():
self.net.add(nn.Dense(self.D, activation="relu"))
m = mf.models.Model(verbose=False)
f = MXFusionGluonFunction(self.net, num_outputs=1)
m.x = mfc.Variable()
m.y = f(m.x)
def func(component):
return 'recursive', 'recursive'
y2 = m.y.replicate(replication_function=func)
self.assertTrue(y2.factor is not None)
def test_set_prior(self):
m = mf.models.Model(verbose=False)
m.x = mfc.Variable()
component_set = set([m.x])
self.assertTrue(
component_set <= set(m._components_graph.nodes().keys()),
"Variables are all added to components_graph {} {}".format(
component_set,
m.components_graph.nodes().keys()))
d = mf.components.distributions.Normal(mean=mx.nd.array([0]),
variance=mx.nd.array([1e6]))
m.x.set_prior(d)
component_set.union(set([d] + [v for _, v in d.inputs]))
self.assertTrue(
component_set <= set(m._components_graph.nodes().keys()),
"Variables are all added to components_graph {} {}".format(
component_set,
m.components_graph.nodes().keys()))
def test_replicate_simple_model(self):
m = mf.models.Model(verbose=False)
m.x = mfc.Variable()
d = mf.components.distributions.Normal(mean=mx.nd.array([0]),
variance=mx.nd.array([1e6]))
m.x.set_prior(d)
m2, var_map = m.clone()
# compare m and m2 components and such for exactness.
self.assertTrue(all([k.uuid == v.uuid for k, v in var_map.items()]))
self.assertTrue(
all([
k.uuid == v.uuid
for k, v in zip(m.components.values(), m2.components.values())
]))
self.assertTrue(all([v in m.components for v in m2.components]),
(set(m2.components) - set(m.components)))
self.assertTrue(all([v in m2.components for v in m.components]),
(set(m.components) - set(m2.components)))
self.assertTrue(
all([
self.shape_match(old.shape, new.shape, var_map) for old, new in
zip(m.variables.values(), m2.variables.values())
]))
def test_remove_nonexistant_variable_failure(self):
v = mfc.Variable()
with self.assertRaises(ModelSpecificationError):
self.fg.remove_component(v)
