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))