def analyse_discrete_data():
"""Run network inference on discrete data."""
data = generate_discrete_data()
settings = {
'cmi_estimator': 'JidtDiscreteCMI',
'discretise_method': 'none',
'n_discrete_bins': 5, # alphabet size of the variables analysed
'min_lag_sources': 1,
'max_lag_sources': 3,
'max_lag_target': 1}
nw = MultivariateTE()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}discrete_results_mte_{1}.p'.format(
path, settings['cmi_estimator']), 'wb'))
nw = BivariateTE()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}discrete_results_bte_{1}.p'.format(
path, settings['cmi_estimator']), 'wb'))
nw = MultivariateMI()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}discrete_results_mmi_{1}.p'.format(
path, settings['cmi_estimator']), 'wb'))
nw = BivariateMI()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}discrete_results_bmi_{1}.p'.format(
path, settings['cmi_estimator']), 'wb'))
def test_checkpoint():
"""Test method for full network analysis."""
n_processes = 5 # the MuTE network has 5 nodes
data = Data(seed=SEED)
data.generate_mute_data(10, 5)
filename_ckp = './my_checkpoint'
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': 5,
'min_lag_sources': 4,
'max_lag_target': 5,
'write_ckp': True,
'filename_ckp': filename_ckp}
nw_0 = MultivariateTE()
# Test all to all analysis
results = nw_0.analyse_network(
settings, data, targets='all', sources='all')
targets_analysed = results.targets_analysed
sources = np.arange(n_processes)
assert all(np.array(targets_analysed) == np.arange(n_processes)), (
'Network analysis did not run on all targets.')
for t in results.targets_analysed:
s = np.array(list(set(sources) - set([t])))
assert all(np.array(results._single_target[t].sources_tested) == s), (
'Network analysis did not run on all sources for target '
'{0}'. format(t))
# Test analysis for subset of targets
target_list = [1, 2, 3]
results = nw_0.analyse_network(
settings, data, targets=target_list, sources='all')
targets_analysed = results.targets_analysed
assert all(np.array(targets_analysed) == np.array(target_list)), (
'Network analysis did not run on correct subset of targets.')
for t in results.targets_analysed:
s = np.array(list(set(sources) - set([t])))
assert all(np.array(results._single_target[t].sources_tested) == s), (
'Network analysis did not run on all sources for target '
'{0}'. format(t))
# Test analysis for subset of sources
source_list = [1, 2, 3]
target_list = [0, 4]
results = nw_0.analyse_network(settings, data, targets=target_list,
sources=source_list)
targets_analysed = results.targets_analysed
assert all(np.array(targets_analysed) == np.array(target_list)), (
'Network analysis did not run for all targets.')
for t in results.targets_analysed:
assert all(results._single_target[t].sources_tested ==
np.array(source_list)), (
'Network analysis did not run on the correct subset '
'of sources for target {0}'.format(t))
_clear_ckp(filename_ckp)
def analyse_continuous_data():
"""Run network inference on continuous data."""
data = generate_continuous_data()
settings = {
'min_lag_sources': 1,
'max_lag_sources': 3,
'max_lag_target': 1}
nw = MultivariateTE()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}continuous_results_mte_{1}.p'.format(
path, estimator), 'wb'))
nw = BivariateTE()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}continuous_results_bte_{1}.p'.format(
path, estimator), 'wb'))
nw = MultivariateMI()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}continuous_results_mmi_{1}.p'.format(
path, estimator), 'wb'))
nw = BivariateMI()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(res, open('{0}continuous_results_bmi_{1}.p'.format(
path, estimator), 'wb'))
def test_multivariate_te_mute():
"""Test multivariate TE estimation on the MUTE example network.
Test data comes from a network that is used as an example in the paper on
the MuTE toolbox (Montalto, PLOS ONE, 2014, eq. 14). The network has the
following (non-linear) couplings:
0 -> 1, u = 2
0 -> 2, u = 3
0 -> 3, u = 2 (non-linear)
3 -> 4, u = 1
4 -> 3, u = 1
The maximum order of any single AR process is never higher than 2.
"""
data = Data()
data.generate_mute_data(n_samples=1000, n_replications=10)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21} # this should be equal to the min stats b/c we
# reuse the surrogate table from the min stats
network_analysis = MultivariateTE()
network_analysis.analyse_network(settings, data, targets=[1, 2])
def test_multivariate_te_mute():
"""Test multivariate TE estimation on the MUTE example network.
Test data comes from a network that is used as an example in the paper on
the MuTE toolbox (Montalto, PLOS ONE, 2014, eq. 14). The network has the
following (non-linear) couplings:
0 -> 1, u = 2
0 -> 2, u = 3
0 -> 3, u = 2 (non-linear)
3 -> 4, u = 1
4 -> 3, u = 1
The maximum order of any single AR process is never higher than 2.
"""
data = Data()
data.generate_mute_data(n_samples=1000, n_replications=10)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21
} # this should be equal to the min stats b/c we
# reuse the surrogate table from the min stats
network_analysis = MultivariateTE()
network_analysis.analyse_network(settings, data, targets=[1, 2])
def test_analyse_network():
"""Test method for full network analysis."""
n_processes = 5 # the MuTE network has 5 nodes
data = Data()
data.generate_mute_data(10, 5)
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': 5,
'min_lag_sources': 4,
'max_lag_target': 5}
nw_0 = MultivariateTE()
# Test all to all analysis
results = nw_0.analyse_network(
settings, data, targets='all', sources='all')
targets_analysed = results.targets_analysed
sources = np.arange(n_processes)
assert all(np.array(targets_analysed) == np.arange(n_processes)), (
'Network analysis did not run on all targets.')
for t in results.targets_analysed:
s = np.array(list(set(sources) - set([t])))
assert all(np.array(results._single_target[t].sources_tested) == s), (
'Network analysis did not run on all sources for target '
'{0}'. format(t))
# Test analysis for subset of targets
target_list = [1, 2, 3]
results = nw_0.analyse_network(
settings, data, targets=target_list, sources='all')
targets_analysed = results.targets_analysed
assert all(np.array(targets_analysed) == np.array(target_list)), (
'Network analysis did not run on correct subset of targets.')
for t in results.targets_analysed:
s = np.array(list(set(sources) - set([t])))
assert all(np.array(results._single_target[t].sources_tested) == s), (
'Network analysis did not run on all sources for target '
'{0}'. format(t))
# Test analysis for subset of sources
source_list = [1, 2, 3]
target_list = [0, 4]
results = nw_0.analyse_network(settings, data, targets=target_list,
sources=source_list)
targets_analysed = results.targets_analysed
assert all(np.array(targets_analysed) == np.array(target_list)), (
'Network analysis did not run for all targets.')
for t in results.targets_analysed:
assert all(results._single_target[t].sources_tested ==
np.array(source_list)), (
'Network analysis did not run on the correct subset '
'of sources for target {0}'.format(t))
def test_multivariate_te_mute():
"""Test multivariate TE estimation on the MUTE example network.
Test data comes from a network that is used as an example in the paper on
the MuTE toolbox (Montalto, PLOS ONE, 2014, eq. 14). The network has the
following (non-linear) couplings:
0 -> 1, u = 2
0 -> 2, u = 3
0 -> 3, u = 2 (non-linear)
3 -> 4, u = 1
4 -> 3, u = 1
The maximum order of any single AR process is never higher than 2.
"""
data = Data()
data.generate_mute_data(n_samples=1000, n_replications=10)
settings = {
'cmi_estimator': 'JidtDiscreteCMI',
'discretise_method': 'max_ent',
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21, # this should be equal to the min stats b/c we
# reuse the surrogate table from the min stats
}
network_analysis = MultivariateTE()
results_me = network_analysis.analyse_network(settings, data,
targets=[1, 2])
settings['discretise_method'] = 'equal'
results_eq = network_analysis.analyse_network(settings, data,
targets=[1, 2])
for t in [1, 2]:
print('Target {0}: equal binning: {1}, max. ent. binning: {2}'.format(
t,
results_eq.get_single_target(t, fdr=False).omnibus_te,
results_me.get_single_target(t, fdr=False).omnibus_te
))
# Skip comparison of estimates if analyses returned different source
# sets. This will always lead to different estimates.
if (results_eq.get_single_target(t, fdr=False).selected_vars_sources ==
results_me.get_single_target(t, fdr=False).selected_vars_sources):
assert (np.isclose(
results_eq.get_single_target(1, fdr=False).omnibus_te,
results_me.get_single_target(1, fdr=False).omnibus_te,
rtol=0.05)), ('Target {0}: unequl results for both binning '
'methods.'.format(t))
else:
continue
def test_return_local_values():
"""Test estimation of local values."""
max_lag = 5
data = Data()
data.generate_mute_data(500, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'local_values': True, # request calculation of local values
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_max_seq': 21,
'n_perm_omnibus': 21,
'max_lag_sources': max_lag,
'min_lag_sources': 4,
'max_lag_target': max_lag
}
target = 1
te = MultivariateTE()
results = te.analyse_network(settings, data, targets=[target])
# Test if any sources were inferred. If not, return (this may happen
# sometimes due to too few samples, however, a higher no. samples is not
# feasible for a unit test).
if results.get_single_target(target, fdr=False)['te'] is None:
return
lte = results.get_single_target(target, fdr=False)['te']
n_sources = len(results.get_target_sources(target, fdr=False))
assert type(lte) is np.ndarray, (
'LTE estimation did not return an array of values: {0}'.format(lte))
assert lte.shape[0] == n_sources, (
'Wrong dim (no. sources) in LTE estimate: {0}'.format(lte.shape))
assert lte.shape[1] == data.n_realisations_samples(
(0, max_lag)), ('Wrong dim (no. samples) in LTE estimate: {0}'.format(
lte.shape))
assert lte.shape[2] == data.n_replications, (
'Wrong dim (no. replications) in LTE estimate: {0}'.format(lte.shape))
# Test for correctnes of single link TE estimation by comparing it to the
# omnibus TE. In this case (single source), the two should be the same.
settings['local_values'] = False
results_avg = te.analyse_network(settings, data, targets=[target])
if results_avg.get_single_target(target, fdr=False)['te'] is None:
return
te_single_link = results_avg.get_single_target(target, fdr=False)['te'][0]
te_omnibus = results_avg.get_single_target(target, fdr=False)['omnibus_te']
assert np.isclose(te_single_link, te_omnibus), (
'Single link TE is not equal to omnibus information transfer.')
# Compare mean local TE to average TE.
assert np.isclose(
te_single_link,
np.mean(lte)), ('Single link average TE and mean LTE deviate.')
def test_multivariate_te_mute():
"""Test multivariate TE estimation on the MUTE example network.
Test data comes from a network that is used as an example in the paper on
the MuTE toolbox (Montalto, PLOS ONE, 2014, eq. 14). The network has the
following (non-linear) couplings:
0 -> 1, u = 2
0 -> 2, u = 3
0 -> 3, u = 2 (non-linear)
3 -> 4, u = 1
4 -> 3, u = 1
The maximum order of any single AR process is never higher than 2.
"""
data = Data()
data.generate_mute_data(n_samples=1000, n_replications=10)
settings = {
'cmi_estimator': 'JidtDiscreteCMI',
'discretise_method': 'max_ent',
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21, # this should be equal to the min stats b/c we
# reuse the surrogate table from the min stats
}
network_analysis = MultivariateTE()
results_me = network_analysis.analyse_network(settings,
data,
targets=[1, 2])
settings['discretise_method'] = 'equal'
results_eq = network_analysis.analyse_network(settings,
data,
targets=[1, 2])
assert (np.isclose(
results_eq.get_single_target(1, fdr=False).omnibus_te,
results_me.get_single_target(1, fdr=False).omnibus_te,
rtol=0.05)), (
'TE into first target is not equal for both binning methods.')
assert (np.isclose(
results_eq.get_single_target(2, fdr=False).omnibus_te,
results_me.get_single_target(2, fdr=False).omnibus_te,
rtol=0.05)), (
'TE into second target is not equal for both binning methods.')
def test_return_local_values():
"""Test estimation of local values."""
max_lag = 5
data = Data()
data.generate_mute_data(500, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'local_values': True, # request calculation of local values
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_max_seq': 21,
'n_perm_omnibus': 21,
'max_lag_sources': max_lag,
'min_lag_sources': 4,
'max_lag_target': max_lag}
target = 1
te = MultivariateTE()
results = te.analyse_network(settings, data, targets=[target])
# Test if any sources were inferred. If not, return (this may happen
# sometimes due to too few samples, however, a higher no. samples is not
# feasible for a unit test).
if results.get_single_target(target, fdr=False)['te'] is None:
return
lte = results.get_single_target(target, fdr=False)['te']
n_sources = len(results.get_target_sources(target, fdr=False))
assert type(lte) is np.ndarray, (
'LTE estimation did not return an array of values: {0}'.format(lte))
assert lte.shape[0] == n_sources, (
'Wrong dim (no. sources) in LTE estimate: {0}'.format(lte.shape))
assert lte.shape[1] == data.n_realisations_samples((0, max_lag)), (
'Wrong dim (no. samples) in LTE estimate: {0}'.format(lte.shape))
assert lte.shape[2] == data.n_replications, (
'Wrong dim (no. replications) in LTE estimate: {0}'.format(lte.shape))
# Test for correctnes of single link TE estimation by comparing it to the
# omnibus TE. In this case (single source), the two should be the same.
settings['local_values'] = False
results_avg = te.analyse_network(settings, data, targets=[target])
if results_avg.get_single_target(target, fdr=False)['te'] is None:
return
te_single_link = results_avg.get_single_target(target, fdr=False)['te'][0]
te_omnibus = results_avg.get_single_target(target, fdr=False)['omnibus_te']
assert np.isclose(te_single_link, te_omnibus), (
'Single link TE is not equal to omnibus information transfer.')
# Compare mean local TE to average TE.
assert np.isclose(te_single_link, np.mean(lte)), (
'Single link average TE and mean LTE deviate.')
def test_visualise_multivariate_te():
"""Visualise output of multivariate TE estimation."""
data = Data()
data.generate_mute_data(100, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 4,
'n_perm_max_stat': 25,
'n_perm_min_stat': 25,
'n_perm_omnibus': 50,
'n_perm_max_seq': 50,
}
network_analysis = MultivariateTE()
results = network_analysis.analyse_network(settings, data,
targets=[0, 1, 2])
# generate graph plots
visualise_graph.plot_selected_vars(results, target=1, sign_sources=False)
plt.show()
visualise_graph.plot_network(results, fdr=False)
plt.show()
visualise_graph.plot_network(results, fdr=True)
plt.show()
visualise_graph.plot_selected_vars(results, target=1, sign_sources=True)
plt.show()
def test_visualise_multivariate_te():
"""Visualise output of multivariate TE estimation."""
data = Data()
data.generate_mute_data(100, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 4,
'n_perm_max_stat': 25,
'n_perm_min_stat': 25,
'n_perm_omnibus': 50,
'n_perm_max_seq': 50,
}
network_analysis = MultivariateTE()
results = network_analysis.analyse_network(settings,
data,
targets=[0, 1, 2])
# generate graph plots
visualise_graph.plot_selected_vars(results, target=1, sign_sources=False)
plt.show()
visualise_graph.plot_network(results, fdr=False)
plt.show()
visualise_graph.plot_network(results, fdr=True)
plt.show()
visualise_graph.plot_selected_vars(results, target=1, sign_sources=True)
plt.show()
def te(mdf1):
import numpy as np
from idtxl.multivariate_te import MultivariateTE
from idtxl.data import Data
n_procs = 1
settings = {
'cmi_estimator': 'JidtDiscreteCMI',
'n_perm_max_stat': 21,
'max_lag_target': 5,
'max_lag_sources': 5,
'min_lag_sources': 4
}
settings['cmi_estimator'] = 'JidtDiscreteCMI'
binary_trains = []
for spiketrain in mdf1.spiketrains:
x = conv.BinnedSpikeTrain(spiketrain,
binsize=5 * pq.ms,
t_start=0 * pq.s)
binary_trains.append(x.to_array())
print(binary_trains)
dat = Data(np.array(binary_trains), dim_order='spr')
dat.n_procs = n_procs
settings = {
'cmi_estimator': 'JidtKraskov',
'max_lag_sources': 3,
'max_lag_target': 3,
'min_lag_sources': 1
}
print(dat)
mte = MultivariateTE()
res_full = mte.analyse_network(settings=settings, data=dat)
# generate graph plots
g_single = visualise_graph.plot_selected_vars(res_single, mte)
g_full = visualise_graph.plot_network(res_full)
def analyse_discrete_data():
"""Run network inference on discrete data."""
data = generate_discrete_data()
settings = {
'cmi_estimator': 'JidtDiscreteCMI',
'discretise_method': 'none',
'n_discrete_bins': 5, # alphabet size of the variables analysed
'min_lag_sources': 1,
'max_lag_sources': 3,
'max_lag_target': 1
}
nw = MultivariateTE()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open(
'{0}discrete_results_mte_{1}.p'.format(path,
settings['cmi_estimator']),
'wb'))
nw = BivariateTE()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open(
'{0}discrete_results_bte_{1}.p'.format(path,
settings['cmi_estimator']),
'wb'))
nw = MultivariateMI()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open(
'{0}discrete_results_mmi_{1}.p'.format(path,
settings['cmi_estimator']),
'wb'))
nw = BivariateMI()
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open(
'{0}discrete_results_bmi_{1}.p'.format(path,
settings['cmi_estimator']),
'wb'))
def analyse_continuous_data():
"""Run network inference on continuous data."""
data = generate_continuous_data()
settings = {
'min_lag_sources': 1,
'max_lag_sources': 3,
'max_lag_target': 1
}
nw = MultivariateTE()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open('{0}continuous_results_mte_{1}.p'.format(path, estimator),
'wb'))
nw = BivariateTE()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open('{0}continuous_results_bte_{1}.p'.format(path, estimator),
'wb'))
nw = MultivariateMI()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open('{0}continuous_results_mmi_{1}.p'.format(path, estimator),
'wb'))
nw = BivariateMI()
for estimator in ['JidtGaussianCMI', 'JidtKraskovCMI']:
settings['cmi_estimator'] = estimator
res = nw.analyse_network(settings=settings, data=data)
pickle.dump(
res,
open('{0}continuous_results_bmi_{1}.p'.format(path, estimator),
'wb'))
def test_combine_results():
"""Test combination of results objects."""
data = _get_discrete_gauss_data()
nw = MultivariateTE()
res_network_1 = nw.analyse_network(settings=settings, data=data)
# Test error for unequal settings
res_network_2 = cp.deepcopy(res_network_1)
res_network_2.settings.add_conditionals = 'Test'
with pytest.raises(RuntimeError):
res_network_1.combine_results(res_network_2)
def test_combine_results():
"""Test combination of results objects."""
data = _generate_gauss_data()
nw = MultivariateTE()
res_network_1 = nw.analyse_network(settings=settings, data=data)
# Test error for unequal settings
res_network_2 = cp.deepcopy(res_network_1)
res_network_2.settings.add_conditionals = 'Test'
with pytest.raises(RuntimeError):
res_network_1.combine_results(res_network_2)
def test_pickle_results():
"""Test pickling results objects."""
data = _generate_gauss_data()
nw = MultivariateTE()
res_single = nw.analyse_single_target(
settings=settings, data=data, target=1)
res_network = nw.analyse_network(settings=settings, data=data)
outfile = TemporaryFile()
pickle.dump(res_single, outfile)
pickle.dump(res_network, outfile)
def test_pickle_results():
"""Test pickling results objects."""
data = _generate_gauss_data()
nw = MultivariateTE()
res_single = nw.analyse_single_target(
settings=settings, data=data, target=1)
res_network = nw.analyse_network(settings=settings, data=data)
outfile = TemporaryFile()
pickle.dump(res_single, outfile)
pickle.dump(res_network, outfile)
def test_plot_network():
"""Test results class for multivariate TE network inference."""
covariance = 0.4
n = 10000
delay = 1
normalisation = False
source = np.random.normal(0, 1, size=n)
target_1 = (covariance * source +
(1 - covariance) * np.random.normal(0, 1, size=n))
target_2 = (covariance * source +
(1 - covariance) * np.random.normal(0, 1, size=n))
source = source[delay:]
target_1 = target_1[:-delay]
target_2 = target_2[:-delay]
# Discretise data for speed
settings_dis = {'discretise_method': 'equal', 'n_discrete_bins': 5}
est = JidtDiscreteCMI(settings_dis)
source_dis, target_1_dis = est._discretise_vars(var1=source, var2=target_1)
source_dis, target_2_dis = est._discretise_vars(var1=source, var2=target_2)
data = Data(np.vstack((source_dis, target_1_dis, target_2_dis)),
dim_order='ps',
normalise=normalisation)
settings = {
'cmi_estimator': 'JidtDiscreteCMI',
'discretise_method': 'none',
'n_discrete_bins': 5, # alphabet size of the variables analysed
'n_perm_max_stat': 21,
'n_perm_omnibus': 30,
'n_perm_max_seq': 30,
'min_lag_sources': 1,
'max_lag_sources': 2,
'max_lag_target': 1,
'alpha_fdr': 0.5
}
nw = MultivariateTE()
# Analyse a single target and the whole network
res_single = nw.analyse_single_target(settings=settings,
data=data,
target=1)
res_network = nw.analyse_network(settings=settings, data=data)
graph, fig = plot_network(res_single, 'max_te_lag', fdr=False)
plt.close(fig)
graph, fig = plot_network(res_network, 'max_te_lag', fdr=False)
plt.close(fig)
for sign_sources in [True, False]:
graph, fig = plot_selected_vars(res_network,
target=1,
sign_sources=True,
fdr=False)
plt.close(fig)
def test_console_output():
data = Data()
data.generate_mute_data(n_samples=10, n_replications=5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 4,
'max_lag_target': 5
}
nw = MultivariateTE()
r = nw.analyse_network(settings, data, targets='all', sources='all')
r.print_edge_list(fdr=False, weights='binary')
def test_console_output():
data = Data()
data.generate_mute_data(n_samples=10, n_replications=5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 4,
'max_lag_target': 5
}
nw = MultivariateTE()
r = nw.analyse_network(settings, data, targets='all', sources='all')
r.print_edge_list(fdr=False, weights='binary')
def test_console_output():
dat = Data()
dat.generate_mute_data(n_samples=10, n_replications=5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 4,
'max_lag_target': 5
}
nw = MultivariateTE()
r = nw.analyse_network(settings, dat, targets='all', sources='all')
print_res_to_console(dat, r, fdr=False)
def analyse_mute_te_data():
# Generate example data: the following was ran once to generate example
# data, which is now in the data sub-folder of the test-folder.
data = Data()
data.generate_mute_data(100, 5)
# analysis settings
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 50,
'n_perm_min_stat': 50,
'n_perm_omnibus': 200,
'n_perm_max_seq': 50,
'max_lag_target': 5,
'max_lag_sources': 5,
'min_lag_sources': 1,
'permute_in_time': True
}
# network inference for individual data sets
nw_0 = MultivariateTE()
res_0 = nw_0.analyse_network(settings, data, targets=[0, 1], sources='all')
pickle.dump(res_0, open(path + 'mute_results_0.p', 'wb'))
res_1 = nw_0.analyse_network(settings, data, targets=[1, 2], sources='all')
pickle.dump(res_1, open(path + 'mute_results_1.p', 'wb'))
res_2 = nw_0.analyse_network(settings, data, targets=[0, 2], sources='all')
pickle.dump(res_2, open(path + 'mute_results_2.p', 'wb'))
res_3 = nw_0.analyse_network(settings,
data,
targets=[0, 1, 2],
sources='all')
pickle.dump(res_3, open(path + 'mute_results_3.p', 'wb'))
res_4 = nw_0.analyse_network(settings, data, targets=[1, 2], sources='all')
pickle.dump(res_4, open(path + 'mute_results_4.p', 'wb'))
res_5 = nw_0.analyse_network(settings, data)
pickle.dump(res_5, open(path + 'mute_results_full.p', 'wb'))
def test_multivariate_te_multiple_runs():
"""Test TE estimation using multiple runs on the GPU.
Test if data is correctly split over multiple runs, if the problem size
exceeds the GPU global memory and thus requires multiple runs. Using a
number of permutations of 7000 requires two runs on a GPU with global
memory of about 6 GB.
"""
data = Data()
data.generate_mute_data(n_samples=1000, n_replications=10)
settings = {
'cmi_estimator': 'OpenCLKraskovCMI',
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'n_perm_max_stat': 7000,
'n_perm_min_stat': 7000,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21} # this should be equal to the min stats b/c we
# reuse the surrogate table from the min stats
network_analysis = MultivariateTE()
network_analysis.analyse_network(settings, data, targets=[1, 2])
def test_multivariate_te_multiple_runs():
"""Test TE estimation using multiple runs on the GPU.
Test if data is correctly split over multiple runs, if the problem size
exceeds the GPU global memory and thus requires multiple runs. Using a
number of permutations of 7000 requires two runs on a GPU with global
memory of about 6 GB.
"""
data = Data()
data.generate_mute_data(n_samples=1000, n_replications=10)
settings = {
'cmi_estimator': 'OpenCLKraskovCMI',
'max_lag_sources': 3,
'min_lag_sources': 1,
'max_lag_target': 3,
'n_perm_max_stat': 7000,
'n_perm_min_stat': 7000,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21
} # this should be equal to the min stats b/c we
# reuse the surrogate table from the min stats
network_analysis = MultivariateTE()
network_analysis.analyse_network(settings, data, targets=[1, 2])
def test_visualise_multivariate_te():
"""Visualise output of multivariate TE estimation."""
dat = Data()
dat.generate_mute_data(100, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 5,
'min_lag_sources': 4,
'n_perm_max_stat': 25,
'n_perm_min_stat': 25,
'n_perm_omnibus': 50,
'n_perm_max_seq': 50,
}
network_analysis = MultivariateTE()
res = network_analysis.analyse_network(settings, dat, targets=[0, 1, 2])
vis.plot_network(res)
def test_permute_time():
"""Create surrogates by permuting data in time instead of over replic."""
# Test if perm type is set to default
default = 'random'
data = Data()
data.generate_mute_data(10, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 21,
'n_perm_max_seq': 21,
'n_perm_omnibus': 21,
'max_lag_sources': 5,
'min_lag_sources': 4,
'max_lag_target': 5,
'permute_in_time': True}
nw_0 = MultivariateTE()
results = nw_0.analyse_network(
settings, data, targets='all', sources='all')
assert results.settings.perm_type == default, (
'Perm type was not set to default.')
def test_permute_time():
"""Create surrogates by permuting data in time instead of over replic."""
# Test if perm type is set to default
default = 'random'
data = Data(seed=SEED)
data.generate_mute_data(10, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 21,
'n_perm_max_seq': 21,
'n_perm_omnibus': 21,
'max_lag_sources': 5,
'min_lag_sources': 4,
'max_lag_target': 5,
'permute_in_time': True}
nw_0 = MultivariateTE()
results = nw_0.analyse_network(
settings, data, targets='all', sources='all')
assert results.settings.perm_type == default, (
'Perm type was not set to default.')
def analyse_mute_te_data():
# Generate example data: the following was ran once to generate example
# data, which is now in the data sub-folder of the test-folder.
data = Data()
data.generate_mute_data(100, 5)
# analysis settings
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 50,
'n_perm_min_stat': 50,
'n_perm_omnibus': 200,
'n_perm_max_seq': 50,
'max_lag_target': 5,
'max_lag_sources': 5,
'min_lag_sources': 1,
'permute_in_time': True
}
# network inference for individual data sets
nw_0 = MultivariateTE()
res_0 = nw_0.analyse_network(
settings, data, targets=[0, 1], sources='all')
pickle.dump(res_0, open(path + 'mute_results_0.p', 'wb'))
res_1 = nw_0.analyse_network(
settings, data, targets=[1, 2], sources='all')
pickle.dump(res_1, open(path + 'mute_results_1.p', 'wb'))
res_2 = nw_0.analyse_network(
settings, data, targets=[0, 2], sources='all')
pickle.dump(res_2, open(path + 'mute_results_2.p', 'wb'))
res_3 = nw_0.analyse_network(
settings, data, targets=[0, 1, 2], sources='all')
pickle.dump(res_3, open(path + 'mute_results_3.p', 'wb'))
res_4 = nw_0.analyse_network(
settings, data, targets=[1, 2], sources='all')
pickle.dump(res_4, open(path + 'mute_results_4.p', 'wb'))
res_5 = nw_0.analyse_network(settings, data)
pickle.dump(res_5, open(path + 'mute_results_full.p', 'wb'))
N_TRIAL, N_DATA, N_NODE = data.shape
#dataIDTxl = Data(data.transpose((2, 0, 1)), dim_order='spr')
dataIDTxl = Data(data, dim_order='rsp')
else:
raise ValueError("Unexpected data shape", data.shape)
# b) Initialise analysis object and define settings
network_analysis = MultivariateTE()
settings = {'cmi_estimator': 'JidtGaussianCMI',
'max_lag_sources': DELAY_MAX,
'min_lag_sources': DELAY_MIN}
# c) Run analysis
results = network_analysis.analyse_network(settings=settings, data=dataIDTxl)
# d) Convert results into comfortable form
results_mat = idtxlResults2matrix(results, N_NODE, method='MultivariateTE')
rez_file_h5.close()
#######################
# Plot Results
#######################
plotImshowMat(
results_mat,
['MultivariateTE', "Delays", "p-value"],
'IDTxl analysis of ' + filename,
(1, 3),
def test_results_network_inference():
"""Test results class for multivariate TE network inference."""
covariance = 0.4
n = 10000
delay = 1
normalisation = False
source = np.random.normal(0, 1, size=n)
target_1 = (covariance * source +
(1 - covariance) * np.random.normal(0, 1, size=n))
target_2 = (covariance * source +
(1 - covariance) * np.random.normal(0, 1, size=n))
corr_expected = covariance / (1 * np.sqrt(covariance**2 +
(1 - covariance)**2))
expected_mi = calculate_mi(corr_expected)
source = source[delay:]
target_1 = target_1[:-delay]
target_2 = target_2[:-delay]
# Discretise data for speed
settings_dis = {'discretise_method': 'equal', 'n_discrete_bins': 5}
est = JidtDiscreteCMI(settings_dis)
source_dis, target_1_dis = est._discretise_vars(var1=source, var2=target_1)
source_dis, target_2_dis = est._discretise_vars(var1=source, var2=target_2)
data = Data(np.vstack((source_dis, target_1_dis, target_2_dis)),
dim_order='ps',
normalise=normalisation)
nw = MultivariateTE()
# TE - single target
res_single_multi_te = nw.analyse_single_target(settings=settings,
data=data,
target=1)
# TE whole network
res_network_multi_te = nw.analyse_network(settings=settings, data=data)
nw = BivariateTE()
# TE - single target
res_single_biv_te = nw.analyse_single_target(settings=settings,
data=data,
target=1)
# TE whole network
res_network_biv_te = nw.analyse_network(settings=settings, data=data)
nw = MultivariateMI()
# TE - single target
res_single_multi_mi = nw.analyse_single_target(settings=settings,
data=data,
target=1)
# TE whole network
res_network_multi_mi = nw.analyse_network(settings=settings, data=data)
nw = BivariateMI()
# TE - single target
res_single_biv_mi = nw.analyse_single_target(settings=settings,
data=data,
target=1)
# TE whole network
res_network_biv_mi = nw.analyse_network(settings=settings, data=data)
res_te = [
res_single_multi_te, res_network_multi_te, res_single_biv_te,
res_network_biv_te
]
res_mi = [
res_single_multi_mi, res_network_multi_mi, res_single_biv_mi,
res_network_biv_mi
]
res_all = res_te + res_mi
# Check estimated values
for res in res_te:
est_te = res._single_target[1].omnibus_te
assert np.isclose(est_te, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: '
'{0}, Actual results: {1}.'.format(expected_mi, est_te))
for res in res_mi:
est_mi = res._single_target[1].omnibus_mi
assert np.isclose(est_mi, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: '
'{0}, Actual results: {1}.'.format(expected_mi, est_mi))
est_te = res_network_multi_te._single_target[2].omnibus_te
assert np.isclose(est_te, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: {0}, '
'Actual results: {1}.'.format(expected_mi, est_te))
est_mi = res_network_multi_mi._single_target[2].omnibus_mi
assert np.isclose(est_mi, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: {0}, '
'Actual results: {1}.'.format(expected_mi, est_mi))
# Check data parameters in results objects
n_nodes = 3
n_realisations = n - delay - max(settings['max_lag_sources'],
settings['max_lag_target'])
for res in res_all:
assert res.data_properties.n_nodes == n_nodes, 'Incorrect no. nodes.'
assert res.data_properties.n_nodes == n_nodes, 'Incorrect no. nodes.'
assert res.data_properties.n_realisations == n_realisations, (
'Incorrect no. realisations.')
assert res.data_properties.n_realisations == n_realisations, (
'Incorrect no. realisations.')
assert res.data_properties.normalised == normalisation, (
'Incorrect value for data normalisation.')
assert res.data_properties.normalised == normalisation, (
'Incorrect value for data normalisation.')
adj_matrix = res.get_adjacency_matrix('binary', fdr=False)
assert adj_matrix._edge_matrix.shape[0] == n_nodes, (
'Incorrect number of rows in adjacency matrix.')
assert adj_matrix._edge_matrix.shape[1] == n_nodes, (
'Incorrect number of columns in adjacency matrix.')
assert adj_matrix._edge_matrix.shape[0] == n_nodes, (
'Incorrect number of rows in adjacency matrix.')
assert adj_matrix._edge_matrix.shape[1] == n_nodes, (
'Incorrect number of columns in adjacency matrix.')
def test_results_network_inference():
"""Test results class for multivariate TE network inference."""
covariance = 0.4
n = 10000
delay = 1
normalisation = False
source = np.random.normal(0, 1, size=n)
target_1 = (covariance * source + (1 - covariance) *
np.random.normal(0, 1, size=n))
target_2 = (covariance * source + (1 - covariance) *
np.random.normal(0, 1, size=n))
corr_expected = covariance / (
1 * np.sqrt(covariance**2 + (1-covariance)**2))
expected_mi = calculate_mi(corr_expected)
source = source[delay:]
target_1 = target_1[:-delay]
target_2 = target_2[:-delay]
# Discretise data for speed
settings_dis = {'discretise_method': 'equal',
'n_discrete_bins': 5}
est = JidtDiscreteCMI(settings_dis)
source_dis, target_1_dis = est._discretise_vars(var1=source, var2=target_1)
source_dis, target_2_dis = est._discretise_vars(var1=source, var2=target_2)
data = Data(np.vstack((source_dis, target_1_dis, target_2_dis)),
dim_order='ps', normalise=normalisation)
nw = MultivariateTE()
# TE - single target
res_single_multi_te = nw.analyse_single_target(
settings=settings, data=data, target=1)
# TE whole network
res_network_multi_te = nw.analyse_network(settings=settings, data=data)
nw = BivariateTE()
# TE - single target
res_single_biv_te = nw.analyse_single_target(
settings=settings, data=data, target=1)
# TE whole network
res_network_biv_te = nw.analyse_network(settings=settings, data=data)
nw = MultivariateMI()
# TE - single target
res_single_multi_mi = nw.analyse_single_target(
settings=settings, data=data, target=1)
# TE whole network
res_network_multi_mi = nw.analyse_network(settings=settings, data=data)
nw = BivariateMI()
# TE - single target
res_single_biv_mi = nw.analyse_single_target(
settings=settings, data=data, target=1)
# TE whole network
res_network_biv_mi = nw.analyse_network(settings=settings, data=data)
res_te = [res_single_multi_te, res_network_multi_te, res_single_biv_te,
res_network_biv_te]
res_mi = [res_single_multi_mi, res_network_multi_mi, res_single_biv_mi,
res_network_biv_mi]
res_all = res_te + res_mi
# Check estimated values
for res in res_te:
est_te = res._single_target[1].omnibus_te
assert np.isclose(est_te, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: '
'{0}, Actual results: {1}.'.format(expected_mi, est_te))
for res in res_mi:
est_mi = res._single_target[1].omnibus_mi
assert np.isclose(est_mi, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: '
'{0}, Actual results: {1}.'.format(expected_mi, est_mi))
est_te = res_network_multi_te._single_target[2].omnibus_te
assert np.isclose(est_te, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: {0}, '
'Actual results: {1}.'.format(expected_mi, est_te))
est_mi = res_network_multi_mi._single_target[2].omnibus_mi
assert np.isclose(est_mi, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: {0}, '
'Actual results: {1}.'.format(expected_mi, est_mi))
# Check data parameters in results objects
n_nodes = 3
n_realisations = n - delay - max(
settings['max_lag_sources'], settings['max_lag_target'])
for res in res_all:
assert res.data_properties.n_nodes == n_nodes, 'Incorrect no. nodes.'
assert res.data_properties.n_nodes == n_nodes, 'Incorrect no. nodes.'
assert res.data_properties.n_realisations == n_realisations, (
'Incorrect no. realisations.')
assert res.data_properties.n_realisations == n_realisations, (
'Incorrect no. realisations.')
assert res.data_properties.normalised == normalisation, (
'Incorrect value for data normalisation.')
assert res.data_properties.normalised == normalisation, (
'Incorrect value for data normalisation.')
adj_matrix = res.get_adjacency_matrix('binary', fdr=False)
assert adj_matrix.shape[0] == n_nodes, (
'Incorrect number of rows in adjacency matrix.')
assert adj_matrix.shape[1] == n_nodes, (
'Incorrect number of columns in adjacency matrix.')
assert adj_matrix.shape[0] == n_nodes, (
'Incorrect number of rows in adjacency matrix.')
assert adj_matrix.shape[1] == n_nodes, (
'Incorrect number of columns in adjacency matrix.')
def run(self):
network_analysis = MultivariateTE()
results = network_analysis.analyse_network(settings=self.settings, data=self.data)
#results.print_edge_list(weights='max_te_lag', fdr=False)
return plot_network(results=results, weights='max_te_lag', fdr=False)
# Import classes
from idtxl.multivariate_te import MultivariateTE
from idtxl.data import Data
from idtxl.visualise_graph import plot_network
import matplotlib.pyplot as plt
# a) Generate test data
data = Data()
data.generate_mute_data(n_samples=1000, n_replications=5)
# b) Initialise analysis object and define settings
network_analysis = MultivariateTE()
settings = {'cmi_estimator': 'JidtGaussianCMI',
'max_lag_sources': 5,
'min_lag_sources': 1}
# c) Run analysis
results = network_analysis.analyse_network(settings=settings, data=data)
# d) Plot inferred network to console and via matplotlib
results.print_edge_list(weights='max_te_lag', fdr=False)
plot_network(results=results, weights='max_te_lag', fdr=False)
plt.show()
# conditioning: (process index, lag)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'history_target': 1,
'n_perm_max_stat': 100,
'alpha_max_stat': 0.05,
'permute_in_time': True,
'max_lag_sources': 5,
'min_lag_sources': 1,
'add_conditionals': [(0, 1), (0, 2), (1, 1), (1, 2)]
}
# c) Run analysis
center_res = network_analysis.analyse_network(settings=settings,
data=data_center,
targets=[6],
sources=[2, 3, 4, 5])
pre_border_res = network_analysis.analyse_network(settings=settings,
data=data_pre_border,
targets=[6],
sources=[2, 3, 4, 5])
# d) Plot inferred network to console and via matplotlib
plot_network(res=center_res, n_nodes=data_center.n_processes)
# print_res_to_console(data=data_pre_border, res=pre_border_res)
# plot_network(res=pre_border_res, n_nodes=data_pre_border.n_processes)
pickle.dump(center_res, open('network_center_b2m1.p', 'wb'))
pickle.dump(pre_border_res, open('network_preborder_b2m1.p', 'wb'))
# pickle.dump(res1, open('results_all_trials.p', 'wb'))
def test_JidtKraskovCMI_MTE_checkpoint():
""" run test without checkpointing, with checkpointing without resume and checkpointing with resume to compare the results"""
filename_ckp1 = os.path.join(
os.path.dirname(__file__), 'data', 'run_checkpoint')
filename_ckp2 = os.path.join(
os.path.dirname(__file__), 'data', 'resume_checkpoint')
"""Test running analysis without any checkpoint setting."""
# Generate test data
data = Data(seed=SEED)
data.generate_mute_data(n_samples=N_SAMPLES, n_replications=1)
# Initialise analysis object and define settings
network_analysis1 = MultivariateTE()
network_analysis2 = MultivariateTE()
network_analysis3 = MultivariateTE()
network_analysis4 = MultivariateTE()
# Settings without checkpointing.
settings1 = {'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': N_PERM,
'n_perm_min_stat': N_PERM,
'n_perm_max_seq': N_PERM,
'n_perm_omnibus': N_PERM,
'max_lag_sources': 3,
'min_lag_sources': 2,
'noise_level': 0
}
# Settings with checkpointing.
settings2 = {'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': N_PERM,
'n_perm_min_stat': N_PERM,
'n_perm_max_seq': N_PERM,
'n_perm_omnibus': N_PERM,
'max_lag_sources': 3,
'min_lag_sources': 2,
'noise_level': 0,
'write_ckp': True,
'filename_ckp': filename_ckp1}
# Settings resuming from checkpoint.
settings3 = {'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': N_PERM,
'n_perm_min_stat': N_PERM,
'n_perm_max_seq': N_PERM,
'n_perm_omnibus': N_PERM,
'max_lag_sources': 3,
'min_lag_sources': 2,
'noise_level': 0,
'write_ckp': True,
'filename_ckp': filename_ckp2}
# Setting sources and targets for the analysis
sources = [0, 1]
targets = [2, 3]
targets2 = [3]
# Starting Analysis of the Network
# results of a network analysis without checkpointing
results1 = network_analysis1.analyse_network(
settings=settings1, data=data, targets=targets, sources=sources)
# results of a network analysis with checkpointing
results2 = network_analysis2.analyse_network(
settings=settings2, data=data, targets=targets, sources=sources)
# Creating a checkpoint similar to the above settings where the targets of
# of the first source have been already analyzed
with open(filename_ckp1 + ".ckp", "r+") as f:
tarsource = f.readlines()
tarsource = tarsource[8]
tarsource = (tarsource[:-1])
network_analysis3._set_checkpointing_defaults(
settings3, data, sources, targets)
with open(filename_ckp2 + ".ckp") as f:
lines = f.read().splitlines()
lines[8] = tarsource
with open(filename_ckp2 + ".ckp", 'w') as f:
f.write('\n'.join(lines))
print(lines)
# Resume analysis.
network_analysis_res = MultivariateTE()
data, settings, targets, sources = network_analysis_res.resume_checkpoint(
filename_ckp2)
# results of a network analysis resuming from checkpoint
results3 = network_analysis_res.analyse_network(
settings=settings3, data=data, targets=targets, sources=sources)
# results of a network analysis without checkpointing but other targets/sources
results4 = network_analysis4.analyse_network(
settings=settings1, data=data, targets=targets2, sources=sources)
adj_matrix1 = results1.get_adjacency_matrix(weights='binary', fdr=False)
adj_matrix2 = results2.get_adjacency_matrix(weights='binary', fdr=False)
adj_matrix3 = results3.get_adjacency_matrix(weights='binary', fdr=False)
adj_matrix4 = results4.get_adjacency_matrix(weights='binary', fdr=False)
result1 = adj_matrix1.get_edge_list()
result2 = adj_matrix2.get_edge_list()
result3 = adj_matrix3.get_edge_list()
result4 = adj_matrix4.get_edge_list()
print("Printing results:")
print("Result 1: without checkpoint")
print(result1)
print("Result 2: with checkpoint")
print(result2)
print("Result 3: resuming from checkpoint")
print(result3)
print("Result 4: without checkpoint and different targets and sources")
print(result4)
print("Comparing the results:")
assert np.array_equal(result1, result2), 'Result 1 and 2 not equal!'
assert np.array_equal(result1, result3), 'Result 1 and 3 not equal!'
assert not np.array_equal(result1, result4), 'Result 1 and 4 equal, expected to be different!'
cmp1 = list(set(result1).intersection(result2))
cmp2 = list(set(result1).intersection(result3))
cmp3 = list(set(result1).intersection(result4))
len1 = len(result1)
assert len(cmp1) == len1 and len(cmp2) == len1 and len(cmp3) != len1, (
"Discrete MultivariateMI Running with checkpoints does not give the expected results")
print("Final")
print("Elements of comparison between result 1 and 2")
print(cmp1)
print("Elements of comparison between result 1 and 3")
print(cmp2)
print("Elements of comparison between result 1 and 4")
print(cmp3)
_clear_ckp(filename_ckp1)
_clear_ckp(filename_ckp2)
# statistical testing - shuffle over time for a max of 200 permutations with standard alpha
# conditioning: (process index, lag)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'history_target': 1,
'n_perm_max_stat': 100,
'alpha_max_stat': 0.05,
'permute_in_time': True,
'max_lag_sources': 5,
'min_lag_sources': 1,
'add_conditionals': [(0, 1), (0, 2), (1, 1), (1, 2)]
}
# c) Run analysis
center_res = network_analysis.analyse_network(settings=settings,
data=data_center)
pre_border_res = network_analysis.analyse_network(settings=settings,
data=data_pre_border)
with open('network_center_full.p', 'wb') as pklc:
pickle.dump(center_res, pklc)
with open('network_preborder_full.p', 'wb') as pklb:
pickle.dump(pre_border_res, pklb)
# compare
# center_res = pickle.load(open('network_center_full.p', 'rb'))
# pre_border_res = pickle.load(open('network_preborder_full.p', 'rb'))
#
# comparison_settings = {
# 'stats_type': 'independent',
# 'cmi_estimator': 'JidtKraskovCMI',
settings_cpu = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 8,
'min_lag_sources': 1,
'max_lag_target': 4
}
settings_gpu = {
'cmi_estimator': 'OpenCLKraskovCMI',
'gpuid': 1,
'max_lag_sources': 8,
'min_lag_sources': 1,
'max_lag_target': 4
}
results = network_analysis.analyse_network(settings=settings_gpu, data=data)
# pickle.dump(results, open(join(mutual_information_folder, "one_second_of_network_interactions_3p4_tp_4p5_secs.pkl"), "wb" ) )
results = pickle.load(
open(
join(mutual_information_folder,
"one_second_of_network_interactions_3p4_tp_4p5_secs.pkl"), "rb"))
# -------------------------------------------------
# CREATE THE MUTUAL INFORMATION MEASURE BETWEEN POSITION AND THE FIRING RATES OF ALL NEURONS (FOR THE WHOLE RECORDING)
# -------------------------------------------------
# Load the clean body markers
updated_markers_filename = join(
dlc_project_folder, 'post_processing',
'cleaned_body_marker_positions_order_{}_gap_{}.df'.format(str(4), str(10)))
updated_body_markers_positions = pd.read_pickle(updated_markers_filename)
"""Plot graph output from multivariate TE estimation.
author: patricia
"""
from idtxl.data import Data
from idtxl.multivariate_te import MultivariateTE
from idtxl import visualise_graph
# Generate some example output
data = Data()
data.generate_mute_data(n_replications=2, n_samples=500)
print('Demo data with {0} procs, {1} samples, {2} reps.'.format(
data.n_processes, data.n_samples, data.n_replications))
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'max_lag_sources': 3,
'max_lag_target': 3,
'min_lag_sources': 1
}
mte = MultivariateTE()
res_single = mte.analyse_single_target(settings=settings, data=data, target=3)
res_full = mte.analyse_network(settings=settings, data=data)
# generate graph plots
g_single = visualise_graph.plot_selected_vars(res_single, mte)
g_full = visualise_graph.plot_network(res_full)
import os
import time
import numpy as np
from idtxl.multivariate_te import MultivariateTE
from idtxl.data import Data
start_time = time.time()
dat = Data() # initialise an empty data object
dat.generate_mute_data(n_samples=1000, n_replications=10)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 500,
'n_perm_min_stat': 200,
'n_perm_omnibus': 500,
'n_perm_max_seq': 500,
'max_lag_sources': 5,
'min_lag_sources': 1
}
network_analysis = MultivariateTE()
res = network_analysis.analyse_network(settings, dat)
runtime = time.time() - start_time
print("---- {0} minutes".format(runtime / 60))
path = os.path.dirname(__file__) + 'output/'
np.save(path + 'test', res)
np.save(path + 'test_time', runtime)
def test_analyse_network():
"""Test method for full network analysis."""
n_processes = 5 # the MuTE network has 5 nodes
dat = Data()
dat.generate_mute_data(10, 5)
settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 21,
'n_perm_max_seq': 21,
'n_perm_omnibus': 21,
'max_lag_sources': 5,
'min_lag_sources': 4,
'max_lag_target': 5
}
nw_0 = MultivariateTE()
# Test all to all analysis
r = nw_0.analyse_network(settings, dat, targets='all', sources='all')
try:
del r['fdr_corrected']
except:
pass
k = list(r.keys())
sources = np.arange(n_processes)
assert all(np.array(k) == np.arange(n_processes)), (
'Network analysis did not run on all targets.')
for t in r.keys():
s = np.array(list(set(sources) - set([t])))
assert all(np.array(r[t]['sources_tested']) == s), (
'Network analysis did not run on all sources for target '
'{0}'.format(t))
# Test analysis for subset of targets
target_list = [1, 2, 3]
r = nw_0.analyse_network(settings, dat, targets=target_list, sources='all')
try:
del r['fdr_corrected']
except:
pass
k = list(r.keys())
assert all(np.array(k) == np.array(target_list)), (
'Network analysis did not run on correct subset of targets.')
for t in r.keys():
s = np.array(list(set(sources) - set([t])))
assert all(np.array(r[t]['sources_tested']) == s), (
'Network analysis did not run on all sources for target '
'{0}'.format(t))
# Test analysis for subset of sources
source_list = [1, 2, 3]
target_list = [0, 4]
r = nw_0.analyse_network(settings,
dat,
targets=target_list,
sources=source_list)
try:
del r['fdr_corrected']
except:
pass
k = list(r.keys())
assert all(np.array(k) == np.array(target_list)), (
'Network analysis did not run for all targets.')
for t in r.keys():
assert all(r[t]['sources_tested'] == np.array(source_list)), (
'Network analysis did not run on the correct subset of sources '
'for target {0}'.format(t))
