def test_save_univariate(self):
"""
Test saving the univariate model
"""
data_path = os.path.join(test_data_dir, 'model_parameters', 'example')
model_path = os.path.join(data_path, 'univariate.json')
leaspy = Leaspy.load(model_path)
# Save the file
save_path = os.path.join(data_path, 'univariate-copy.json')
leaspy.save(save_path)
# Check that the files are the same
with open(model_path, 'r') as f1:
model_parameters = json.load(f1)
with open(save_path, 'r') as f2:
model_parameters_new = json.load(f2)
self.assertEqual(model_parameters.keys(), model_parameters_new.keys())
self.assertEqual(model_parameters['parameters'].keys(),
model_parameters_new['parameters'].keys())
for k, v in model_parameters['parameters'].items():
diff = np.array(v) - np.array(
model_parameters_new['parameters'][k])
self.assertAlmostEqual(np.sum(diff**2).item(), 0, delta=10e-8)
# Remove the created file
os.remove(save_path)
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_initialize_parameters(self, ):
settings = AlgorithmSettings('scipy_minimize')
algo = ScipyMinimize(settings)
univariate_path = os.path.join(test_data_dir, 'model_parameters',
'example', 'univariate.json')
univariate_model = Leaspy.load(univariate_path)
param = algo._initialize_parameters(univariate_model.model)
self.assertEqual(param, [torch.tensor([-1.0]), torch.tensor([70.0])])
multivariate_path = os.path.join(test_data_dir, 'model_parameters',
'example', 'logistic.json')
multivariate_model = Leaspy.load(multivariate_path)
param = algo._initialize_parameters(multivariate_model.model)
self.assertEqual(param, [
torch.tensor([0.0]),
torch.tensor([75.2]),
torch.tensor([0.]),
torch.tensor([0.])
])
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_get_regularity(self):
multivariate_path = os.path.join(test_data_dir, 'model_parameters',
'example', 'logistic.json')
leaspy = Leaspy.load(multivariate_path)
settings = AlgorithmSettings('scipy_minimize')
algo = ScipyMinimize(settings)
algo._set_model_name('logistic')
individual_parameters = [0.0, 75.2, 0., 0.]
reg = algo._get_regularity(leaspy.model, individual_parameters)
self.assertEqual(torch.is_tensor(reg), True)
output = torch.tensor([4.0264])
self.assertAlmostEqual(torch.sum((reg - output)**2).item(),
0,
delta=10e-9)
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_get_attachment(self):
multivariate_path = os.path.join(test_data_dir, 'model_parameters',
'example', 'logistic.json')
leaspy = Leaspy.load(multivariate_path)
settings = AlgorithmSettings('scipy_minimize')
algo = ScipyMinimize(settings)
algo._set_model_name('logistic')
times = torch.tensor([70, 80])
values = torch.tensor([[0.5, 0.4, 0.4, 0.45], [0.3, 0.3, 0.2, 0.4]])
individual_parameters = [0.0, 75.2, 0., 0.]
err = algo._get_attachment(leaspy.model, times, values,
individual_parameters)
output = torch.tensor([[[-0.4705, -0.3278, -0.3103, -0.4477],
[0.6059, 0.0709, 0.3537, 0.4523]]])
self.assertEqual(torch.is_tensor(err), True)
self.assertAlmostEqual(torch.sum((err - output)**2).item(),
0,
delta=10e-8)
def test_get_individual_parameters_patient_multivariate(self):
multivariate_path = os.path.join(test_data_dir, 'model_parameters',
'example', 'logistic.json')
leaspy = Leaspy.load(multivariate_path)
settings = AlgorithmSettings('scipy_minimize', seed=0)
algo = ScipyMinimize(settings)
# test tolerance, lack of precision btw different machines... (no exact reproductibility in scipy.optimize.minimize?)
tol = 5e-3
# manually initialize seed since it's not done by algo itself (no call to run afterwards)
algo._initialize_seed(algo.seed)
self.assertEqual(algo.seed, np.random.get_state()[1][0])
times = torch.tensor([70, 80])
# Test without nan
values = torch.tensor([[0.5, 0.4, 0.4, 0.45], [0.3, 0.3, 0.2, 0.4]])
output = algo._get_individual_parameters_patient(
leaspy.model, times, values)
individual_parameters = output[0]
err = output[1]
self.assertAlmostEqual(individual_parameters[0],
78.93283994514304,
delta=tol)
self.assertAlmostEqual(individual_parameters[1],
-0.07679465847751077,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[0],
-0.07733279,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[1],
-0.57428166,
delta=tol)
err_expected = torch.tensor([[[-0.4958, -0.3619, -0.3537, -0.4497],
[0.1650, -0.0948, 0.1361, -0.1050]]])
self.assertAlmostEqual(torch.sum((err - err_expected)**2).item(),
0,
delta=tol)
# Test with nan
values = torch.tensor([[0.5, 0.4, 0.4, float('nan')],
[0.3, float('nan'),
float('nan'), 0.4]])
output = algo._get_individual_parameters_patient(
leaspy.model, times, values)
individual_parameters = output[0]
err = output[1]
self.assertAlmostEqual(individual_parameters[0],
78.82484683798302,
delta=tol)
self.assertAlmostEqual(individual_parameters[1],
-0.07808162619234782,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[0],
-0.17007795,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[1],
-0.63483322,
delta=tol)
nan_positions = torch.tensor([[False, False, False, True],
[False, True, True, False]])
self.assertEqual(torch.all(torch.eq(torch.isnan(err), nan_positions)),
True)
err[err != err] = 0.
err_expected = torch.tensor([[[-0.4957, -0.3613, -0.3516, 0.],
[0.1718, 0., 0., -0.0796]]])
self.assertAlmostEqual(torch.sum((err - err_expected)**2).item(),
0,
delta=tol)
def test_get_individual_parameters_patient_crossentropy(self):
multivariate_path = os.path.join(test_data_dir, 'model_parameters',
'example', 'logistic.json')
leaspy = Leaspy.load(multivariate_path)
settings = AlgorithmSettings('scipy_minimize',
seed=0,
loss="crossentropy")
algo = ScipyMinimize(settings)
# test tolerance, lack of precision btw different machines... (no exact reproductibility in scipy.optimize.minimize?)
tol = 5e-3
# manually initialize seed since it's not done by algo itself (no call to run afterwards)
algo._initialize_seed(algo.seed)
self.assertEqual(algo.seed, np.random.get_state()[1][0])
times = torch.tensor([70, 80])
# Test without nan
values = torch.tensor([[0., 1., 0., 1.], [0., 1., 1., 1.]])
output = algo._get_individual_parameters_patient(
leaspy.model, times, values)
individual_parameters = output[0]
err = output[1]
self.assertAlmostEqual(individual_parameters[0],
69.91258208274421,
delta=tol)
self.assertAlmostEqual(individual_parameters[1],
-0.1446537485712681,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[0],
-0.16517799,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[1],
-0.82381726,
delta=tol)
err_expected = torch.tensor([[[0.3184, -0.8266, 0.2943, -0.8065],
[0.9855, -0.4526, -0.2114, -0.0048]]])
self.assertAlmostEqual(torch.sum((err - err_expected)**2).item(),
0,
delta=tol)
# Test with nan
values = torch.tensor([[0., 1., 0., float('nan')],
[0., float('nan'),
float('nan'), 1.]])
output = algo._get_individual_parameters_patient(
leaspy.model, times, values)
individual_parameters = output[0]
err = output[1]
self.assertAlmostEqual(individual_parameters[0],
76.57318992643758,
delta=tol)
self.assertAlmostEqual(individual_parameters[1],
-0.06489393539830259,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[0],
-0.08735905,
delta=tol)
self.assertAlmostEqual(individual_parameters[2].tolist()[1],
-0.37562645,
delta=tol)
nan_positions = torch.tensor([[False, False, False, True],
[False, True, True, False]])
self.assertEqual(torch.all(torch.eq(torch.isnan(err), nan_positions)),
True)
err[err != err] = 0.
err_expected = torch.tensor([[[0.0150, -0.9417, 0.0752, 0.],
[0.7702, 0., 0., -0.3218]]])
self.assertAlmostEqual(torch.sum((err - err_expected)**2).item(),
0,
delta=tol)