def test_max_statistic_sequential():
data = Data()
data.generate_mute_data(104, 10)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21,
'max_lag_sources': 5,
'min_lag_sources': 1,
'max_lag_target': 5
}
setup = MultivariateTE()
setup._initialise(settings, data, sources=[0, 1], target=2)
setup.current_value = (0, 4)
setup.selected_vars_sources = [(1, 1), (1, 2)]
setup.selected_vars_full = [(0, 1), (1, 1), (1, 2)]
setup._selected_vars_realisations = np.random.rand(
data.n_realisations(setup.current_value),
len(setup.selected_vars_full))
setup._current_value_realisations = np.random.rand(
data.n_realisations(setup.current_value),
1)
[sign, p, te] = stats.max_statistic_sequential(analysis_setup=setup,
data=data)
def test_multivariate_te_one_realisation_per_replication():
"""Test boundary case of one realisation per replication."""
# Create a data set where one pattern fits into the time series exactly
# once, this way, we get one realisation per replication for each variable.
# This is easyer to assert/verify later. We also test data.get_realisations
# this way.
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 21,
'max_lag_target': 5,
'max_lag_sources': 5,
'min_lag_sources': 4
}
target = 0
data = Data(normalise=False)
n_repl = 10
n_procs = 2
n_points = n_procs * (settings['max_lag_sources'] + 1) * n_repl
data.set_data(
np.arange(n_points).reshape(n_procs, settings['max_lag_sources'] + 1,
n_repl), 'psr')
nw_0 = MultivariateTE()
nw_0._initialise(settings, data, 'all', target)
assert (not nw_0.selected_vars_full)
assert (not nw_0.selected_vars_sources)
assert (not nw_0.selected_vars_target)
assert ((nw_0._replication_index == np.arange(n_repl)).all())
assert (nw_0._current_value == (target,
max(settings['max_lag_sources'],
settings['max_lag_target'])))
assert (nw_0._current_value_realisations[:, 0] == data.data[target,
-1, :]).all()
def test_add_conditional_manually():
"""Enforce the conditioning on additional variables."""
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 3,
'max_lag_target': 7
}
nw = MultivariateTE()
data = Data()
data.generate_mute_data()
# Add a conditional with a lag bigger than the max_lag requested above
settings['add_conditionals'] = (8, 0)
with pytest.raises(IndexError):
nw._initialise(settings, data, sources=[1, 2], target=0)
# Add valid conditionals and test if they were added
settings['add_conditionals'] = [(0, 1), (1, 3)]
nw._initialise(settings=settings, data=data, target=0, sources=[1, 2])
# Get list of conditionals after intialisation and convert absolute samples
# back to lags for comparison.
cond_list = nw._idx_to_lag(nw.selected_vars_full)
assert settings['add_conditionals'][0] in cond_list, (
'First enforced conditional is missing from results.')
assert settings['add_conditionals'][1] in cond_list, (
'Second enforced conditional is missing from results.')
def test_add_conditional_manually():
"""Enforce the conditioning on additional variables."""
settings = {'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 3,
'max_lag_target': 7}
nw = MultivariateTE()
data = Data()
data.generate_mute_data()
# Add a conditional with a lag bigger than the max_lag requested above
settings['add_conditionals'] = (8, 0)
with pytest.raises(IndexError):
nw._initialise(settings, data, sources=[1, 2], target=0)
# Add valid conditionals and test if they were added
settings['add_conditionals'] = [(0, 1), (1, 3)]
nw._initialise(settings=settings, data=data, target=0, sources=[1, 2])
# Get list of conditionals after intialisation and convert absolute samples
# back to lags for comparison.
cond_list = nw._idx_to_lag(nw.selected_vars_full)
assert settings['add_conditionals'][0] in cond_list, (
'First enforced conditional is missing from results.')
assert settings['add_conditionals'][1] in cond_list, (
'Second enforced conditional is missing from results.')
def test_save_json():
# Test writing dictionaries to JSON files
data = Data()
data.generate_mute_data(n_samples=100, n_replications=1)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_max_seq': 21,
'n_perm_omnibus': 21,
'max_lag_sources': 2,
'min_lag_sources': 1
}
target = 1
sources = [0]
nw = MultivariateTE()
nw._initialise(settings, data, sources, target)
nw._include_target_candidates(data)
nw._include_source_candidates(data)
nw._prune_candidates(data)
nw._test_final_conditional(data)
fd, file_path = tempfile.mkstemp()
try:
# Save settings after running multivariate TE estimation with minimal
# settings.
_save_load_json(nw.settings, file_path)
# Add numpy array
nw.settings['y_test_array'] = np.arange(10)
_save_load_json(nw.settings, file_path)
# Add numpy float
nw.settings['z_test_float'] = np.float64(10)
_save_load_json(nw.settings, file_path)
finally:
os.remove(file_path)
def test_multivariate_te_one_realisation_per_replication():
"""Test boundary case of one realisation per replication."""
# Create a data set where one pattern fits into the time series exactly
# once, this way, we get one realisation per replication for each variable.
# This is easyer to assert/verify later. We also test data.get_realisations
# this way.
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 21,
'max_lag_target': 5,
'max_lag_sources': 5,
'min_lag_sources': 4}
target = 0
data = Data(normalise=False)
n_repl = 10
n_procs = 2
n_points = n_procs * (settings['max_lag_sources'] + 1) * n_repl
data.set_data(np.arange(n_points).reshape(
n_procs,
settings['max_lag_sources'] + 1,
n_repl), 'psr')
nw_0 = MultivariateTE()
nw_0._initialise(settings, data, 'all', target)
assert (not nw_0.selected_vars_full)
assert (not nw_0.selected_vars_sources)
assert (not nw_0.selected_vars_target)
assert ((nw_0._replication_index == np.arange(n_repl)).all())
assert (nw_0._current_value == (target, max(
settings['max_lag_sources'], settings['max_lag_target'])))
assert (nw_0._current_value_realisations[:, 0] ==
data.data[target, -1, :]).all()
def test_faes_method():
"""Check if the Faes method is working."""
settings = {'cmi_estimator': 'JidtKraskovCMI',
'add_conditionals': 'faes',
'max_lag_sources': 5,
'min_lag_sources': 3,
'max_lag_target': 7}
nw_1 = MultivariateTE()
data = Data(seed=SEED)
data.generate_mute_data()
sources = [1, 2, 3]
target = 0
nw_1._initialise(settings, data, sources, target)
assert (nw_1._selected_vars_sources ==
[i for i in it.product(sources, [nw_1.current_value[1]])]), (
'Did not add correct additional conditioning vars.')
def test_faes_method():
"""Check if the Faes method is working."""
settings = {'cmi_estimator': 'JidtKraskovCMI',
'add_conditionals': 'faes',
'max_lag_sources': 5,
'min_lag_sources': 3,
'max_lag_target': 7}
nw_1 = MultivariateTE()
data = Data()
data.generate_mute_data()
sources = [1, 2, 3]
target = 0
nw_1._initialise(settings, data, sources, target)
assert (nw_1._selected_vars_sources ==
[i for i in it.product(sources, [nw_1.current_value[1]])]), (
'Did not add correct additional conditioning vars.')
def test_add_conditional_manually():
"""Adda variable that is not in the data set."""
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'add_conditionals': (8, 0),
'max_lag_sources': 5,
'min_lag_sources': 3,
'max_lag_target': 7
}
nw_1 = MultivariateTE()
dat = Data()
dat.generate_mute_data()
sources = [1, 2, 3]
target = 0
with pytest.raises(IndexError):
nw_1._initialise(settings, dat, sources, target)
def test_network_fdr():
settings = {'n_perm_max_seq': 1000, 'n_perm_omnibus': 1000}
target_0 = {
'selected_vars_sources': [(1, 1), (1, 2), (1, 3), (2, 1), (2, 0)],
'selected_vars_full': [(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3),
(2, 1), (2, 0)],
'omnibus_pval': 0.0001,
'omnibus_sign': True,
'selected_sources_pval': np.array([0.001, 0.0014, 0.01, 0.045, 0.047]),
'selected_sources_te': np.array([1.1, 1.0, 0.8, 0.7, 0.63]),
}
target_1 = {
'selected_vars_sources': [(1, 2), (2, 1), (2, 2)],
'selected_vars_full': [(1, 0), (1, 1), (1, 2), (2, 1), (2, 2)],
'omnibus_pval': 0.031,
'omnibus_sign': True,
'selected_sources_pval': np.array([0.00001, 0.00014, 0.01]),
'selected_sources_te': np.array([1.8, 1.75, 0.75]),
}
target_2 = {
'selected_vars_sources': [],
'selected_vars_full': [(2, 0), (2, 1)],
'omnibus_pval': 0.41,
'omnibus_sign': False,
'selected_sources_pval': None,
'selected_sources_te': np.array([]),
}
res_1 = ResultsNetworkInference(
n_nodes=3, n_realisations=1000, normalised=True)
res_1._add_single_result(target=0, settings=settings, results=target_0)
res_1._add_single_result(target=1, settings=settings, results=target_1)
res_2 = ResultsNetworkInference(
n_nodes=3, n_realisations=1000, normalised=True)
res_2._add_single_result(target=2, settings=settings, results=target_2)
for correct_by_target in [True, False]:
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'alpha_fdr': 0.05,
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'correct_by_target': correct_by_target}
data = Data()
data.generate_mute_data(n_samples=100, n_replications=3)
analysis_setup = MultivariateTE()
analysis_setup._initialise(settings=settings, data=data,
sources=[1, 2], target=0)
res_pruned = stats.network_fdr(settings, res_1, res_2)
assert (not res_pruned._single_target[2].selected_vars_sources), (
'Target 2 has not been pruned from results.')
for k in res_pruned.targets_analysed:
if res_pruned._single_target[k]['selected_sources_pval'] is None:
assert (
not res_pruned._single_target[k]['selected_vars_sources'])
else:
assert (
len(res_pruned._single_target[k]['selected_vars_sources']) ==
len(res_pruned._single_target[k]['selected_sources_pval'])), (
'Source list and list of p-values should have '
'the same length.')
# Test function call for single result
res_pruned = stats.network_fdr(settings, res_1)
print('successful call on single result dict.')
# Test None result for insufficient no. permutations, no FDR-corrected
# results (the results class throws an error if no FDR-corrected results
# exist).
res_1.settings['n_perm_max_seq'] = 2
res_2.settings['n_perm_max_seq'] = 2
res_pruned = stats.network_fdr(settings, res_1, res_2)
with pytest.raises(RuntimeError):
res_pruned.get_adjacency_matrix('binary', fdr=True)
def test_network_fdr():
target_0 = {
'selected_vars_sources': [(1, 1), (1, 2), (1, 3), (2, 1), (2, 0)],
'selected_vars_full': [(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3),
(2, 1), (2, 0)],
'omnibus_pval':
0.0001,
'omnibus_sign':
True,
'selected_sources_pval':
np.array([0.001, 0.0014, 0.01, 0.045, 0.047]),
'selected_sources_te':
np.array([1.1, 1.0, 0.8, 0.7, 0.63]),
'settings': {
'n_perm_max_seq': 1000,
'n_perm_omnibus': 1000
}
}
target_1 = {
'selected_vars_sources': [(1, 2), (2, 1), (2, 2)],
'selected_vars_full': [(1, 0), (1, 1), (1, 2), (2, 1), (2, 2)],
'omnibus_pval': 0.031,
'omnibus_sign': True,
'selected_sources_pval': np.array([0.00001, 0.00014, 0.01]),
'selected_sources_te': np.array([1.8, 1.75, 0.75]),
'settings': {
'n_perm_max_seq': 1000,
'n_perm_omnibus': 1000
}
}
target_2 = {
'selected_vars_sources': [],
'selected_vars_full': [(2, 0), (2, 1)],
'omnibus_pval': 0.41,
'omnibus_sign': False,
'selected_sources_pval': None,
'selected_sources_te': np.array([]),
'settings': {
'n_perm_max_seq': 1000,
'n_perm_omnibus': 1000
}
}
res_1 = {
0: target_0,
1: target_1,
}
res_2 = {2: target_2}
for correct_by_target in [True, False]:
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'alpha_fdr': 0.05,
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'correct_by_target': correct_by_target
}
dat = Data()
dat.generate_mute_data(n_samples=100, n_replications=3)
analysis_setup = MultivariateTE()
analysis_setup._initialise(settings=settings,
data=dat,
sources=[1, 2],
target=0)
res_pruned = stats.network_fdr(settings, res_1, res_2)
assert (not res_pruned[2]['selected_vars_sources']), ('Target ')
for k in res_pruned.keys():
if res_pruned[k]['selected_sources_pval'] is None:
assert (not res_pruned[k]['selected_vars_sources'])
else:
assert (len(res_pruned[k]['selected_vars_sources']) == len(
res_pruned[k]['selected_sources_pval'])), (
'Source list and list of p-values should have '
'the same length.')
# Test function call for single result
res_pruned = stats.network_fdr(settings, res_1)
print('successful call on single result dict.')
# Test None result for insufficient no. permutations
res_1[0]['settings']['n_perm_max_seq'] = 2
res_pruned = stats.network_fdr(settings, res_1, res_2)
assert not res_pruned, ('Res. should be None is no. permutations too low.')
