def test_load_univariate(self):
"""
Test the initialization of a linear model from a json file
"""
model_path = os.path.join(test_data_dir, 'model_parameters', 'example',
'univariate.json')
leaspy = Leaspy.load(model_path)
# Test the name
self.assertEqual(leaspy.type, 'univariate')
self.assertEqual(type(leaspy.model),
type(ModelFactory.model('univariate')))
# Test the hyperparameters
self.assertEqual(leaspy.model.features, ['feature'])
self.assertEqual(leaspy.model.loss, 'MSE')
# Test the parameters
parameters = {
"g": 1.0,
"tau_mean": 70.0,
"tau_std": 2.5,
"xi_mean": -1.0,
"xi_std": 0.01,
"noise_std": 0.2
}
for k, v in parameters.items():
equality = torch.all(
torch.eq(leaspy.model.parameters[k], tensor(v)))
self.assertEqual(equality, True)
# Test the initialization
self.assertEqual(leaspy.model.is_initialized, True)
def test_lower_case(self):
"""Test lower case"""
name_examples = ['univariate', 'uNIVariaTE', 'UNIVARIATE']
for name in name_examples:
model = ModelFactory.model(name)
# Test model type
self.assertEqual(type(model), UnivariateModel)
def __init__(self, model_name):
"""
Instantiate a Leaspy class object.
Parameters
----------
model_name : str
Model's name
"""
self.model = ModelFactory.model(model_name)
self.type = model_name
self.plotting = Plotting(self.model)
def test_constructor(self):
"""
Test attribute's initialization of leaspy univariate model
:return: exit code
"""
for name in [
'univariate', 'linear', 'logistic', 'logistic_parallel',
'mixed_linear-logistic'
]:
leaspy = Leaspy(name)
self.assertEqual(leaspy.type, name)
self.assertEqual(type(leaspy.model),
type(ModelFactory.model(name)))
ModelFactoryTest().test_model_factory_constructor(leaspy.model)
def test_model_factory_constructor(self, model=None):
"""
Test initialization of leaspy model.
Parameters
----------
model : str, optional (default None)
Name of the model
"""
if model is None:
for name in [
'univariate', 'linear', 'logistic', 'logistic_parallel'
]:
self.test_model_factory_constructor(ModelFactory().model(name))
else:
if model.name == 'univariate':
self.assertEqual(type(model), UnivariateModel)
elif model.name == 'logistic' or model.name == 'linear':
self.assertEqual(type(model), MultivariateModel)
elif model.name == 'logistic_parallel':
self.assertEqual(type(model), MultivariateParallelModel)
def test_load_logistic_parallel(self):
"""
Test the initialization of a logistic parallel model from a json file
"""
model_path = os.path.join(test_data_dir, 'model_parameters', 'example',
'logistic_parallel.json')
leaspy = Leaspy.load(model_path)
# Test the name
self.assertEqual(leaspy.type, 'logistic_parallel')
self.assertEqual(type(leaspy.model),
type(ModelFactory.model('logistic_parallel')))
# Test the hyperparameters
self.assertEqual(leaspy.model.dimension, 4)
self.assertEqual(leaspy.model.features,
['feature_0', 'feature_1', 'feature_2', 'feature_3'])
self.assertEqual(leaspy.model.source_dimension, 2)
self.assertEqual(leaspy.model.loss, 'MSE')
# Test the parameters
parameters = {
"g": 1.0,
"tau_mean": 70.4,
"tau_std": 7.0,
"xi_mean": -1.7,
"xi_std": 1.0,
"sources_mean": 0.0,
"sources_std": 1.0,
"noise_std": 0.1,
"deltas": [-3, -2.5, -1.0],
"betas": [[0.1, -0.1], [0.5, -0.3], [0.3, 0.4]],
}
for k, v in parameters.items():
equality = torch.all(
torch.eq(leaspy.model.parameters[k], tensor(v)))
self.assertEqual(equality, True)
# Test the initialization
self.assertEqual(leaspy.model.is_initialized, True)
def test_audit_individual_parameters(self):
# tuple: (valid,nb_inds,src_dim), ips_as_dict
all_ips = [
# 0 individual
((True, 0, 0), {'tau':[],'xi':[]}),
((True, 0, 5), {'tau':[],'xi':[],'sources':[]}), # src_dim undefined here...
# 1 individual
((True, 1, 0), {'tau':50,'xi':0,}),
((False, 1, 1), {'tau':50,'xi':0,'sources':0}), # faulty (source should be vector)
((True, 1, 1), {'tau':50,'xi':0,'sources':[0]}),
((True, 1, 2), {'tau':50,'xi':0,'sources':[0,0]}),
# 2 individuals
((True, 2, 0), {'tau':[50,60],'xi':[0,0.1],}),
((True, 2, 1), {'tau':[50,60],'xi':[0,0.1],'sources':[0,0.1]}), # accepted even if ambiguous
((True, 2, 1), {'tau':[50,60],'xi':[0,0.1],'sources':[[0],[0.1]]}), # cleaner
((True, 2, 2), {'tau':[50,60],'xi':[0,0.1],'sources':[[0,-1],[0.1,0]]}),
# Faulty
((False, 1, 0), {'tau':0,'xi':0,'extra':0}),
((False, 1, 0), {'tau':0,}),
((False, None, 0), {'tau':[50,60],'xi':[0]}),
]
for src_compat, m in [
(lambda src_dim: src_dim <= 0, ModelFactory.model('univariate')),
(lambda src_dim: src_dim >= 0, ModelFactory.model('logistic'))
]:
for (valid,n_inds,src_dim), ips in all_ips:
if m.name == 'logistic':
m.source_dimension = src_dim
if (not valid) or (not src_compat(src_dim)):
with self.assertRaises(ValueError, ):
ips_info = m.audit_individual_parameters(ips)
continue
ips_info = m.audit_individual_parameters(ips)
keys = set(ips_info.keys()).symmetric_difference({'nb_inds','tensorized_ips','tensorized_ips_gen'})
self.assertEqual(len(keys), 0)
self.assertEqual(ips_info['nb_inds'], n_inds)
list_t_ips = list(ips_info['tensorized_ips_gen'])
self.assertEqual(len(list_t_ips), n_inds)
t_ips = ips_info['tensorized_ips']
self.assertIsInstance(t_ips, dict)
keys_ips = set(t_ips.keys()).symmetric_difference(ips.keys())
self.assertEqual(len(keys_ips), 0)
for k,v in t_ips.items():
self.assertIsInstance(v, torch.Tensor)
self.assertEqual(v.dim(), 2)
self.assertEqual(v.shape, (n_inds, src_dim if (k == 'sources') and (n_inds > 0) else 1))
if n_inds == 1:
t_ips0 = list_t_ips[0]
self.assertTrue(all(torch.equal(t_ips0[k], v) for k,v in t_ips.items())) # because only 1 individual
elif n_inds > 1:
for t_ips_1i in list_t_ips:
for k,v in t_ips_1i.items():
self.assertIsInstance(v, torch.Tensor)
self.assertEqual(v.dim(), 2)
self.assertEqual(v.shape, (1, src_dim if (k == 'sources') else 1))