def test_get_item(self):
ip = IndividualParameters()
p1 = {"xi": 0.1, "tau": 70, "sources": [0.1, -0.3]}
p2 = {"xi": 0.2, "tau": 73, "sources": [-0.4, 0.1]}
ip.add_individual_parameters("idx1", p1)
ip.add_individual_parameters("idx2", p2)
self.assertDictEqual(ip['idx1'], p1)
self.assertDictEqual(ip['idx2'], p2)
def test_constructor(self):
ip = IndividualParameters()
self.assertEqual(ip._indices, [])
self.assertEqual(ip._individual_parameters, {})
self.assertEqual(ip._parameters_shape, None) # changed
self.assertEqual(ip._default_saving_type, "csv")
def test_from_dataframe(self):
ip = IndividualParameters.from_dataframe(self.ip_df)
self.assertEqual(ip._indices, self.indices)
self.assertEqual(ip._individual_parameters, self.individual_parameters)
self.assertEqual(ip._parameters_shape, self.parameters_shape)
def test_load_individual_parameters(self):
# Test json
ip_json = IndividualParameters.load(self.path_json)
self.assertEqual(ip_json._indices, self.indices)
self.assertEqual(ip_json._individual_parameters,
self.individual_parameters)
self.assertEqual(ip_json._parameters_shape, self.parameters_shape)
# Test csv
ip_csv = IndividualParameters.load(self.path_csv)
self.assertEqual(ip_csv._indices, self.indices)
self.assertEqual(ip_csv._individual_parameters,
self.individual_parameters)
self.assertEqual(ip_csv._parameters_shape, self.parameters_shape)
def test_check_and_get_extension(self):
tests = [('file.csv', 'csv'), ('path/to/file.csv', 'csv'),
('file.json', 'json'), ('path/to/file.json', 'json'),
('nopath', False), ('bad_path.bad', 'bad')]
for test in tests:
ext = IndividualParameters._check_and_get_extension(test[0])
self.assertEqual(ext, test[1])
def test_from_to_pytorch(self):
ip = IndividualParameters.from_pytorch(self.indices, self.ip_pytorch)
ip_indices, ip_pytorch2 = ip.to_pytorch()
ip2 = IndividualParameters.from_pytorch(ip_indices, ip_pytorch2)
# Test Individual parameters
self.assertEqual(ip._indices, ip2._indices)
self.assertDictEqual(ip._individual_parameters,
ip2._individual_parameters)
self.assertDictEqual(ip._parameters_shape, ip2._parameters_shape)
# Test Pytorch dictionaries
self.assertEqual(self.ip_pytorch.keys(), ip_pytorch2.keys())
for k in self.ip_pytorch.keys():
for v1, v2 in zip(self.ip_pytorch[k], ip_pytorch2[k]):
self.assertTrue((v1.numpy() - v2.numpy() == 0).all())
def test_to_from_dataframe(self):
ip1 = IndividualParameters.from_dataframe(self.ip_df)
df2 = ip1.to_dataframe()
ip2 = IndividualParameters.from_dataframe(df2)
# Test between individual parameters
self.assertEqual(ip1._indices, ip2._indices)
self.assertDictEqual(ip1._individual_parameters,
ip2._individual_parameters)
self.assertDictEqual(ip1._parameters_shape, ip2._parameters_shape)
# Test between dataframes
self.assertTrue((self.ip_df.values == df2.values).all())
self.assertTrue((self.ip_df.index == df2.index).all())
for n1, n2 in zip(self.ip_df.columns, df2.columns):
self.assertEqual(n1, n2)
def test_from_pytorch(self):
"""
"""
ip = IndividualParameters.from_pytorch(self.indices, self.ip_pytorch)
self.assertEqual(ip._indices, self.indices)
self.assertEqual(ip._individual_parameters.keys(),
self.individual_parameters.keys())
self.assertDictEqual(ip._parameters_shape, self.parameters_shape)
for k, v in self.individual_parameters.items():
for kk, vv in self.individual_parameters[k].items():
self.assertTrue(kk in ip._individual_parameters[k].keys())
if np.ndim(vv) == 0:
self.assertAlmostEqual(ip._individual_parameters[k][kk],
vv,
delta=10e-8)
else:
l2 = ip._individual_parameters[k][kk]
for s1, s2 in zip(vv, l2):
self.assertAlmostEqual(s1, s2, delta=10e-8)
def setUp(self):
self.indices = ['idx1', 'idx2', 'idx3']
self.p1 = {"xi": 0.1, "tau": 70, "sources": [0.1, -0.3]}
self.p2 = {"xi": 0.2, "tau": 73, "sources": [-0.4, 0.1]}
self.p3 = {"xi": 0.3, "tau": 58, "sources": [-0.6, 0.2]}
self.parameters_shape = {"xi": (), "tau": (), "sources": (2, )}
self.individual_parameters = {
"idx1": self.p1,
"idx2": self.p2,
"idx3": self.p3
}
ip = IndividualParameters()
ip.add_individual_parameters("idx1", self.p1)
ip.add_individual_parameters("idx2", self.p2)
ip.add_individual_parameters("idx3", self.p3)
self.ip = ip
self.ip_df = pd.DataFrame(
data=[[0.1, 70, 0.1, -0.3], [0.2, 73, -0.4, 0.1],
[0.3, 58, -0.6, 0.2]],
index=["idx1", "idx2", "idx3"],
columns=["xi", "tau", "sources_0", "sources_1"])
self.ip_pytorch = {
"xi":
torch.tensor([[0.1], [0.2], [0.3]], dtype=torch.float32),
"tau":
torch.tensor([[70], [73], [58.]], dtype=torch.float32),
"sources":
torch.tensor([[0.1, -0.3], [-0.4, 0.1], [-0.6, 0.2]],
dtype=torch.float32)
}
self.path_json = os.path.join(test_data_dir, "io", "outputs",
"ip_save.json")
self.path_csv = os.path.join(test_data_dir, "io", "outputs",
"ip_save.csv")
def test_individual_parameters(self):
ip = IndividualParameters()
p1 = {"xi": 0.1, "tau": 70, "sources": [0.1, -0.3]}
p2 = {"xi": 0.2, "tau": 73, "sources": [-0.4, 0.1]}
p3 = {"xi": 0.3, "tau": 58, "sources": [-0.6, 0.2]}
ip.add_individual_parameters("idx1", p1)
ip.add_individual_parameters("idx2", p2)
ip.add_individual_parameters("idx3", p3)
## test fail index exist
with self.assertRaises(ValueError):
ip.add_individual_parameters('idx1', p3)
## test fail index numeric
with self.assertRaises(ValueError):
ip.add_individual_parameters(1, p1)
## test fail expect scalar
with self.assertRaises(ValueError):
ip.add_individual_parameters('tau_list', {
'tau': [0.2],
'xi': .1,
'sources': [0, 0]
})
## test fail missing key
with self.assertRaises(ValueError):
ip.add_individual_parameters('no_xi', {
'tau': 0.2,
'sources': [0, 0]
})
self.assertEqual(ip._indices, ["idx1", "idx2", "idx3"])
self.assertEqual(ip._indices, list(ip._individual_parameters.keys())
) # TODO: delete indices? as they should be dict keys
self.assertEqual(ip._individual_parameters, {
"idx1": p1,
"idx2": p2,
"idx3": p3
})
self.assertEqual(ip._parameters_shape, {
"xi": (),
"tau": (),
"sources": (2, )
})
self.assertEqual(ip._parameters_size, {
"xi": 1,
"tau": 1,
"sources": 2
})
### test with 1 source only (previous bug)
ip1 = IndividualParameters()
src1 = {'tau': 73, 'xi': .1, 'sources': [0.14]}
ip1.add_individual_parameters('id1', src1)
ip1.add_individual_parameters('id2', src1)
self.assertEqual(ip1._parameters_shape, {
"xi": (),
"tau": (),
"sources": (1, )
})
self.assertEqual(ip1._parameters_size, {
"xi": 1,
"tau": 1,
"sources": 1
})
## test fail compat nb sources 1 != 2
with self.assertRaises(ValueError):
ip1.add_individual_parameters('id_fail', p1)
## test columns of dataframe
# previously would have been "sources" for 1 source which is not generic...
self.assertEqual({'tau', 'xi', 'sources_0'},
set(ip1.to_dataframe().columns))
# previously one would get a column named "sources", with a string encoded list of 1 element at each row...
self.assertTrue(
pd.api.types.is_numeric_dtype(ip1.to_dataframe().dtypes.all()))
def test_load_json(self):
ip = IndividualParameters._load_json(self.path_json)
self.assertEqual(ip._indices, self.indices)
self.assertEqual(ip._individual_parameters, self.individual_parameters)
self.assertEqual(ip._parameters_shape, self.parameters_shape)
path_analysis = os.path.join(path_output, "analysis")
if not os.path.exists(path_analysis):
os.makedirs(path_analysis)
# TODO save and load that info somewhere
n_folds = 3
n_rep = 2
n_resampling_iter = n_folds*n_rep
#%% Load results from folds
# Load individual_parameters objects
individual_parameters_iter = []
for cv_iter in range(n_resampling_iter):
individual_parameters_iter.append(IndividualParameters.load(os.path.join(path_output_personalize, "individual_parameters_{}.json".format(cv_iter))))
# Get calibrated models paths
model_paths = [os.path.join(path_output_calibrate, "fold_{}".format(i), "model_parameters.json") for i in range(n_resampling_iter)]
# Load leaspy objects
leaspy_iter = []
for i in range(n_folds*n_rep):
leaspy = Leaspy.load(model_paths[i])
leaspy_iter.append(leaspy)
# Load indices
import json
with open(os.path.join(path_output, "resampling_indices.json"), "r") as json_file:
indices_resampling = json.load(json_file)