def test_build_meta_dict_empty_violate_mandatory(self):
my_dict = {}
default_setting = MetaDictSetting(meta_dict={
'A': 1,
'B': {
'c': [2, 3],
'd': 'xyz'
},
'alpha': 1,
'permute': True
},
mandatory_fields=['A'])
with self.assertRaises(ConfigurationError):
build_meta_dict(my_dict, default_setting)
def test_build_meta_dict_invertible_override_default(self):
my_dict = {'n_params': 100}
default_setting = DEFAULT_SETTING_INVERTIBLE_NET
correct_result = DEFAULT_SETTING_INVERTIBLE_NET.meta_dict
self.assertEqual(build_meta_dict(my_dict, default_setting),
correct_result)
def test_build_meta_dict_invariant_override_default(self):
my_dict = {
'n_dense_s1': 100,
'n_equiv': 200,
'dense_s1_args': {
'units': 300
},
}
default_setting = DEFAULT_SETTING_INVARIANT_NET
correct_result = {
'n_dense_s1': 100,
'n_dense_s2': 2,
'n_dense_s3': 2,
'n_equiv': 200,
'dense_s1_args': {
'activation': 'relu',
'units': 300
},
'dense_s2_args': {
'activation': 'relu',
'units': 64
},
'dense_s3_args': {
'activation': 'relu',
'units': 32
}
}
self.assertEqual(build_meta_dict(my_dict, default_setting),
correct_result)
def test_build_meta_dict_invariant_empty_my_dict(self):
my_dict = {}
default_setting = DEFAULT_SETTING_INVARIANT_NET
correct_result = DEFAULT_SETTING_INVARIANT_NET.meta_dict
self.assertEqual(build_meta_dict(my_dict, default_setting),
correct_result)
def test_build_meta_dict_nonempty_fulfil_mandatory_nested_full_override(
self):
my_dict = {
'A': 100,
'B': {
'c': [100, 100],
'd': 'ZZZ'
},
}
default_setting = MetaDictSetting(meta_dict={
'A': 1,
'B': {
'c': [2, 3],
'd': 'xyz'
},
'alpha': 1,
'permute': True
},
mandatory_fields=['A'])
correct_result = {
'A': 100,
'B': {
'c': [100, 100],
'd': 'ZZZ'
},
'alpha': 1,
'permute': True
}
self.assertEqual(build_meta_dict(my_dict, default_setting),
correct_result)
def test_no_generative_model(self):
D = 6
J = 6
bf_meta = build_meta_dict({'n_params': D, 'n_models': J}, DEFAULT_SETTING_INVARIANT_BAYES_FLOW)
amortizer = ex.amortizers.InvariantBayesFlow(bf_meta)
trainer = MetaTrainer(amortizer,
loss=kl_latent_space,
learning_rate=.0003
)
generative_model = GenerativeModel(
model_prior,
[TPrior(D // 2, 1.0, 5.0)] * J,
[MultivariateTSimulator(df) for df in np.arange(1, J + 1, 1)]
)
model_indices, params, sim_data = generative_model(64, 128)
_losses = trainer.train_offline(2, 16, model_indices, params, sim_data)
with self.assertRaises(OperationNotSupportedError):
_losses = trainer.train_online(epochs=2, iterations_per_epoch=20, batch_size=32, n_obs=110)
with self.assertRaises(OperationNotSupportedError):
_losses = trainer.train_rounds(epochs=1, rounds=5, sim_per_round=100, batch_size=32, n_obs=110)
with self.assertRaises(OperationNotSupportedError):
_losses = trainer.simulate_and_train_offline(n_sim=100, epochs=2, batch_size=16, n_obs=110)
def __init__(self, meta={}):
super(InvariantNetwork, self).__init__()
meta = build_meta_dict(
user_dict=meta,
default_setting=default_settings.DEFAULT_SETTING_INVARIANT_NET)
self.equiv_seq = Sequential(
[EquivariantModule(meta) for _ in range(meta['n_equiv'])])
self.inv = InvariantModule(meta)
def test_build_meta_dict_empty_fulfil_mandatory(self):
my_dict = {}
default_setting = MetaDictSetting(meta_dict={
'A': 1,
'B': {
'c': [2, 3],
'd': 'xyz'
},
'alpha': 1,
'permute': True
},
mandatory_fields=[])
self.assertEqual(build_meta_dict(my_dict, default_setting),
default_setting.meta_dict)
def setUpClass(cls):
D = 10
J = 10
bf_meta = build_meta_dict({'n_params': D, 'n_models': J}, DEFAULT_SETTING_INVARIANT_BAYES_FLOW)
amortizer = ex.amortizers.InvariantBayesFlow(bf_meta)
generative_model = GenerativeModel(
model_prior,
[TPrior(D // 2, 1.0, 5.0)] * J,
[MultivariateTSimulator(df) for df in np.arange(1, J + 1, 1)]
)
trainer = MetaTrainer(amortizer,
generative_model,
loss=kl_latent_space,
learning_rate=.0003
)
cls.trainer = trainer
def test_build_meta_dict_invertible_minimal(self):
my_dict = {'n_params': 100}
default_setting = DEFAULT_SETTING_INVERTIBLE_NET
correct_result = {
'n_params': 100,
'n_coupling_layers': 4,
's_args': {
'units': [128, 128],
'activation': 'elu',
'initializer': 'glorot_uniform',
},
't_args': {
'units': [128, 128],
'activation': 'elu',
'initializer': 'glorot_uniform',
},
'alpha': 1.9,
'permute': True
}
self.assertEqual(build_meta_dict(my_dict, default_setting),
correct_result)
def __init__(self, meta={}):
""" Creates a chain of cINN blocks and chains operations with an optional summary network.
Parameters
----------
meta : list(dict)
A list of dictionaries, where each dictionary holds parameter-value pairs
for a single :class:`keras.Dense` layer
Notes
-----
TODO: Allow for generic base distributions
"""
super(InvertibleNetwork, self).__init__()
meta = build_meta_dict(
user_dict=meta,
default_setting=default_settings.DEFAULT_SETTING_INVERTIBLE_NET)
self.cINNs = [
ConditionalCouplingLayer(meta)
for _ in range(meta['n_coupling_layers'])
]
self.z_dim = meta['n_params']
def test_build_meta_dict_invertible_violate_mandatory(self):
my_dict = {'n_coupling_layers': 100}
default_setting = DEFAULT_SETTING_INVERTIBLE_NET
with self.assertRaises(ConfigurationError):
build_meta_dict(my_dict, default_setting)
