def test_discrete_input():
"""Test bivariate MI estimation from discrete data."""
# Generate Gaussian test data
covariance = 0.4
data = _get_discrete_gauss_data(covariance=covariance,
n=10000,
delay=1,
normalise=False,
seed=SEED)
corr_expected = covariance / (1 * np.sqrt(covariance**2 +
(1 - covariance)**2))
expected_mi = calculate_mi(corr_expected)
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
}
nw = BivariateMI()
res = nw.analyse_single_target(settings=settings, data=data, target=1)
assert np.isclose(
res._single_target[1].omnibus_mi, expected_mi, atol=0.05), (
'Estimated MI for discrete variables is not correct. Expected: '
'{0}, Actual results: {1}.'.format(expected_mi,
res['selected_sources_mi'][0]))
def _get_gauss_data(n=10000, covariance=0.4, expand=True):
"""Generate correlated and uncorrelated Gaussian variables.
Generate two sets of random normal data, where one set has a given
covariance and the second is uncorrelated.
"""
corr_expected = covariance / (1 * np.sqrt(covariance**2 + (1-covariance)**2))
expected_mi = calculate_mi(corr_expected)
src_corr = [rn.normalvariate(0, 1) for r in range(n)] # correlated src
src_uncorr = [rn.normalvariate(0, 1) for r in range(n)] # uncorrelated src
target = [sum(pair) for pair in zip(
[covariance * y for y in src_corr[0:n]],
[(1-covariance) * y for y in [
rn.normalvariate(0, 1) for r in range(n)]])]
# Make everything numpy arrays so jpype understands it. Add an additional
# axis if requested (MI/CMI estimators accept 2D arrays, TE/AIS only 1D).
if expand:
src_corr = np.expand_dims(np.array(src_corr), axis=1)
src_uncorr = np.expand_dims(np.array(src_uncorr), axis=1)
target = np.expand_dims(np.array(target), axis=1)
else:
src_corr = np.array(src_corr)
src_uncorr = np.array(src_uncorr)
target = np.array(target)
return expected_mi, src_corr, src_uncorr, target
def _get_gauss_data(n=10000, covariance=0.4, expand=True):
"""Generate correlated and uncorrelated Gaussian variables.
Generate two sets of random normal data, where one set has a given
covariance and the second is uncorrelated.
"""
corr_expected = covariance / (1 * np.sqrt(covariance**2 +
(1 - covariance)**2))
expected_mi = calculate_mi(corr_expected)
src_corr = [rn.normalvariate(0, 1) for r in range(n)] # correlated src
src_uncorr = [rn.normalvariate(0, 1) for r in range(n)] # uncorrelated src
target = [
sum(pair)
for pair in zip([covariance * y for y in src_corr[0:n]],
[(1 - covariance) * y
for y in [rn.normalvariate(0, 1) for r in range(n)]])
]
# Make everything numpy arrays so jpype understands it. Add an additional
# axis if requested (MI/CMI estimators accept 2D arrays, TE/AIS only 1D).
if expand:
src_corr = np.expand_dims(np.array(src_corr), axis=1)
src_uncorr = np.expand_dims(np.array(src_uncorr), axis=1)
target = np.expand_dims(np.array(target), axis=1)
else:
src_corr = np.array(src_corr)
src_uncorr = np.array(src_uncorr)
target = np.array(target)
return expected_mi, src_corr, src_uncorr, target
def test_discrete_input():
"""Test bivariate TE estimation from discrete data."""
# Generate Gaussian test data
covariance = 0.4
n = 10000
delay = 1
source = np.random.normal(0, 1, size=n)
target = (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 = target[:-delay]
# Discretise data
settings = {'discretise_method': 'equal', 'n_discrete_bins': 5}
est = JidtDiscreteCMI(settings)
source_dis, target_dis = est._discretise_vars(var1=source, var2=target)
data = Data(np.vstack((source_dis, target_dis)),
dim_order='ps',
normalise=False)
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
}
nw = BivariateTE()
res = nw.analyse_single_target(settings=settings, data=data, target=1)
assert np.isclose(
res._single_target[1].omnibus_te, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: '
'{0}, Actual results: {1}.'.format(
expected_mi, res._single_target[1].omnibus_te))
def test_calculate_cmi_all_links():
"""Test if the CMI is estimated correctly."""
data = Data()
n = 1000
cov = 0.4
source = [rn.normalvariate(0, 1) for r in range(n)] # correlated src
target = [0] + [
sum(pair) for pair in zip([cov * y for y in source[0:n - 1]], [
(1 - cov) * y
for y in [rn.normalvariate(0, 1) for r in range(n - 1)]
])
]
data.set_data(np.vstack((source, target)), 'ps')
res_0 = np.load(
os.path.join(os.path.dirname(__file__), 'data/mute_results_0.p'))
comp_settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 50,
'n_perm_min_stat': 50,
'n_perm_omnibus': 200,
'n_perm_max_seq': 50,
'tail': 'two',
'n_perm_comp': 6,
'alpha_comp': 0.2,
'stats_type': 'dependent'
}
comp = NetworkComparison()
comp._initialise(comp_settings)
comp._create_union(res_0)
comp.union._single_target[1]['selected_vars_sources'] = [(0, 4)]
cmi = comp._calculate_cmi_all_links(data)
corr_expected = cov / (1 * np.sqrt(cov**2 + (1 - cov)**2))
expected_cmi = calculate_mi(corr_expected)
print('correlated Gaussians: TE result {0:.4f} bits; expected to be '
'{1:0.4f} bit for the copy'.format(cmi[1][0], expected_cmi))
np.testing.assert_almost_equal(
cmi[1][0],
expected_cmi,
decimal=1,
err_msg='when calculating cmi for correlated Gaussians.')
def test_discrete_input():
"""Test bivariate TE estimation from discrete data."""
# Generate Gaussian test data
covariance = 0.4
n = 10000
delay = 1
source = np.random.normal(0, 1, size=n)
target = (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 = target[:-delay]
# Discretise data
settings = {'discretise_method': 'equal',
'n_discrete_bins': 5}
est = JidtDiscreteCMI(settings)
source_dis, target_dis = est._discretise_vars(var1=source, var2=target)
data = Data(np.vstack((source_dis, target_dis)),
dim_order='ps', normalise=False)
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}
nw = BivariateTE()
res = nw.analyse_single_target(settings=settings, data=data, target=1)
assert np.isclose(
res._single_target[1].omnibus_te, expected_mi, atol=0.05), (
'Estimated TE for discrete variables is not correct. Expected: '
'{0}, Actual results: {1}.'.format(
expected_mi, res._single_target[1].omnibus_te))
def test_calculate_cmi_all_links():
"""Test if the CMI is estimated correctly."""
data = Data()
n = 1000
cov = 0.4
source = [rn.normalvariate(0, 1) for r in range(n)] # correlated src
target = [0] + [sum(pair) for pair in zip(
[cov * y for y in source[0:n - 1]],
[(1 - cov) * y for y in
[rn.normalvariate(0, 1) for r in range(n - 1)]])]
data.set_data(np.vstack((source, target)), 'ps')
res_0 = np.load(os.path.join(os.path.dirname(__file__),
'data/mute_results_0.p'))
comp_settings = {
'cmi_estimator': 'JidtKraskovCMI',
'n_perm_max_stat': 50,
'n_perm_min_stat': 50,
'n_perm_omnibus': 200,
'n_perm_max_seq': 50,
'tail': 'two',
'n_perm_comp': 6,
'alpha_comp': 0.2,
'stats_type': 'dependent'
}
comp = NetworkComparison()
comp._initialise(comp_settings)
comp._create_union(res_0)
comp.union._single_target[1]['selected_vars_sources'] = [(0, 4)]
cmi = comp._calculate_cmi_all_links(data)
corr_expected = cov / (1 * np.sqrt(cov**2 + (1-cov)**2))
expected_cmi = calculate_mi(corr_expected)
print('correlated Gaussians: TE result {0:.4f} bits; expected to be '
'{1:0.4f} bit for the copy'.format(cmi[1][0], expected_cmi))
np.testing.assert_almost_equal(
cmi[1][0], expected_cmi, decimal=1,
err_msg='when calculating cmi for correlated Gaussians.')
def test_multivariate_te_corr_gaussian(estimator=None):
"""Test multivariate TE estimation on correlated Gaussians.
Run the multivariate TE algorithm on two sets of random Gaussian data with
a given covariance. The second data set is shifted by one sample creating
a source-target delay of one sample. This example is modeled after the
JIDT demo 4 for transfer entropy. The resulting TE can be compared to the
analytical result (but expect some error in the estimate).
The simulated delay is 1 sample, i.e., the algorithm should find
significant TE from sample (0, 1), a sample in process 0 with lag/delay 1.
The final target sample should always be (1, 1), the mandatory sample at
lat 1, because there is no memory in the process.
Note:
This test runs considerably faster than other system tests.
This produces strange small values for non-coupled sources. TODO
"""
if estimator is None:
estimator = 'JidtKraskovCMI'
n = 1000
cov = 0.4
source = [rn.normalvariate(0, 1) for r in range(n)]
target = [
sum(pair)
for pair in zip([cov * y for y in source],
[(1 - cov) * y
for y in [rn.normalvariate(0, 1) for r in range(n)]])
]
# Cast everything to numpy so the idtxl estimator understands it.
source = np.expand_dims(np.array(source), axis=1)
target = np.expand_dims(np.array(target), axis=1)
data = Data(normalise=True)
data.set_data(np.vstack((source[1:].T, target[:-1].T)), 'ps')
settings = {
'cmi_estimator': estimator,
'max_lag_sources': 5,
'min_lag_sources': 1,
'max_lag_target': 5,
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21,
}
random_analysis = MultivariateTE()
results = random_analysis.analyse_single_target(settings, data, 1)
# Assert that there are significant conditionals from the source for target
# 1. For 500 repetitions I got mean errors of 0.02097686 and 0.01454073 for
# examples 1 and 2 respectively. The maximum errors were 0.093841 and
# 0.05833172 repectively. This inspired the following error boundaries.
corr_expected = cov / (1 * np.sqrt(cov**2 + (1 - cov)**2))
expected_res = calculate_mi(corr_expected)
estimated_res = results.get_single_target(1, fdr=False).omnibus_te
diff = np.abs(estimated_res - expected_res)
print('Expected source sample: (0, 1)\nExpected target sample: (1, 1)')
print(('Estimated TE: {0:5.4f}, analytical result: {1:5.4f}, error:'
'{2:2.2f} % ').format(estimated_res, expected_res,
diff / expected_res))
assert (diff < 0.1), ('Multivariate TE calculation for correlated '
'Gaussians failed (error larger 0.1: {0}, expected: '
'{1}, actual: {2}).'.format(diff, expected_res,
estimated_res))
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 test_delay_reconstruction():
"""Test the reconstruction of information transfer delays from results."""
covariance = 0.4
corr_expected = covariance / (
1 * np.sqrt(covariance**2 + (1-covariance)**2))
expected_mi = calculate_mi(corr_expected)
n = 10000
delay_1 = 1
delay_2 = 3
delay_3 = 5
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))
target_3 = (covariance * source + (1 - covariance) *
np.random.normal(0, 1, size=n))
source = source[delay_3:]
target_1 = target_1[(delay_3-delay_1):-delay_1]
target_2 = target_2[(delay_3-delay_2):-delay_2]
target_3 = target_3[:-delay_3]
# 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)
source_dis, target_3_dis = est._discretise_vars(var1=source, var2=target_3)
data = Data(
np.vstack((source_dis, target_1_dis, target_2_dis, target_3_dis)),
dim_order='ps', normalise=normalisation)
nw = MultivariateTE()
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': delay_3 + 1,
'max_lag_target': 1}
res_network = nw.analyse_single_target(
settings=settings, data=data, target=1)
res_network.combine_results(nw.analyse_single_target(
settings=settings, data=data, target=2))
res_network.combine_results(nw.analyse_single_target(
settings=settings, data=data, target=3))
adj_mat = res_network.get_adjacency_matrix('max_te_lag', fdr=False)
print(adj_mat)
assert adj_mat[0, 1] == delay_1, ('Estimate for delay 1 is not correct.')
assert adj_mat[0, 2] == delay_2, ('Estimate for delay 2 is not correct.')
assert adj_mat[0, 3] == delay_3, ('Estimate for delay 3 is not correct.')
for target in range(1, 4):
est_mi = res_network._single_target[target].omnibus_te
assert np.isclose(est_mi, expected_mi, atol=0.05), (
'Estimated TE for target {0} is not correct. Expected: {1}, '
'Actual results: {2}.'.format(target, expected_mi, est_mi))
def test_multivariate_te_corr_gaussian(estimator=None):
"""Test multivariate TE estimation on correlated Gaussians.
Run the multivariate TE algorithm on two sets of random Gaussian data with
a given covariance. The second data set is shifted by one sample creating
a source-target delay of one sample. This example is modeled after the
JIDT demo 4 for transfer entropy. The resulting TE can be compared to the
analytical result (but expect some error in the estimate).
The simulated delay is 1 sample, i.e., the algorithm should find
significant TE from sample (0, 1), a sample in process 0 with lag/delay 1.
The final target sample should always be (1, 1), the mandatory sample at
lat 1, because there is no memory in the process.
Note:
This test runs considerably faster than other system tests.
This produces strange small values for non-coupled sources. TODO
"""
if estimator is None:
estimator = 'JidtKraskovCMI'
n = 1000
cov = 0.4
source = [rn.normalvariate(0, 1) for r in range(n)]
target = [sum(pair) for pair in zip(
[cov * y for y in source],
[(1 - cov) * y for y in [rn.normalvariate(0, 1) for r in range(n)]])]
# Cast everything to numpy so the idtxl estimator understands it.
source = np.expand_dims(np.array(source), axis=1)
target = np.expand_dims(np.array(target), axis=1)
data = Data(normalise=True)
data.set_data(np.vstack((source[1:].T, target[:-1].T)), 'ps')
settings = {
'cmi_estimator': estimator,
'max_lag_sources': 5,
'min_lag_sources': 1,
'max_lag_target': 5,
'n_perm_max_stat': 21,
'n_perm_min_stat': 21,
'n_perm_omnibus': 21,
'n_perm_max_seq': 21,
}
random_analysis = MultivariateTE()
results = random_analysis.analyse_single_target(settings, data, 1)
# Assert that there are significant conditionals from the source for target
# 1. For 500 repetitions I got mean errors of 0.02097686 and 0.01454073 for
# examples 1 and 2 respectively. The maximum errors were 0.093841 and
# 0.05833172 repectively. This inspired the following error boundaries.
corr_expected = cov / (1 * np.sqrt(cov**2 + (1-cov)**2))
expected_res = calculate_mi(corr_expected)
estimated_res = results.get_single_target(1, fdr=False).omnibus_te
diff = np.abs(estimated_res - expected_res)
print('Expected source sample: (0, 1)\nExpected target sample: (1, 1)')
print(('Estimated TE: {0:5.4f}, analytical result: {1:5.4f}, error:'
'{2:2.2f} % ').format(
estimated_res, expected_res, diff / expected_res))
assert (diff < 0.1), ('Multivariate TE calculation for correlated '
'Gaussians failed (error larger 0.1: {0}, expected: '
'{1}, actual: {2}).'.format(
diff, expected_res, estimated_res))
import numpy as np
from idtxl.estimators_jidt import (JidtDiscreteAIS, JidtDiscreteCMI,
JidtDiscreteMI, JidtDiscreteTE,
JidtKraskovAIS, JidtKraskovCMI,
JidtKraskovMI, JidtKraskovTE,
JidtGaussianAIS, JidtGaussianCMI,
JidtGaussianMI, JidtGaussianTE)
from idtxl.estimators_opencl import OpenCLKraskovMI, OpenCLKraskovCMI
from idtxl.estimators_pid import SydneyPID, TartuPID
from idtxl.idtxl_utils import calculate_mi
# Generate Gaussian test data
n = 10000
covariance = 0.4
corr_expected = covariance / (1 * np.sqrt(covariance**2 + (1-covariance)**2))
expected_mi = calculate_mi(corr_expected)
source_cor = np.random.normal(0, 1, size=n) # correlated src
source_uncor = np.random.normal(0, 1, size=n) # uncorrelated src
target = (covariance * source_cor +
(1 - covariance) * np.random.normal(0, 1, size=n))
# JIDT Discrete estimators
settings = {'discretise_method': 'equal', 'alph1': 5, 'alph2': 5}
est = JidtDiscreteCMI(settings)
cmi = est.estimate(source_cor, target, source_uncor)
print('Estimated CMI: {0:.5f}, expected CMI: {1:.5f}'.format(cmi, expected_mi))
est = JidtDiscreteMI(settings)
mi = est.estimate(source_cor, target)
print('Estimated MI: {0:.5f}, expected MI: {1:.5f}'.format(mi, expected_mi))
settings['history_target'] = 1
est = JidtDiscreteTE(settings)
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_delay_reconstruction():
"""Test the reconstruction of information transfer delays from results."""
covariance = 0.4
corr_expected = covariance / (1 * np.sqrt(covariance**2 +
(1 - covariance)**2))
expected_mi = calculate_mi(corr_expected)
n = 10000
delay_1 = 1
delay_2 = 3
delay_3 = 5
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))
target_3 = (covariance * source +
(1 - covariance) * np.random.normal(0, 1, size=n))
source = source[delay_3:]
target_1 = target_1[(delay_3 - delay_1):-delay_1]
target_2 = target_2[(delay_3 - delay_2):-delay_2]
target_3 = target_3[:-delay_3]
# 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)
source_dis, target_3_dis = est._discretise_vars(var1=source, var2=target_3)
data = Data(np.vstack(
(source_dis, target_1_dis, target_2_dis, target_3_dis)),
dim_order='ps',
normalise=normalisation)
nw = MultivariateTE()
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': delay_3 + 1,
'max_lag_target': 1
}
res_network = nw.analyse_single_target(settings=settings,
data=data,
target=1)
res_network.combine_results(
nw.analyse_single_target(settings=settings, data=data, target=2))
res_network.combine_results(
nw.analyse_single_target(settings=settings, data=data, target=3))
adj_mat = res_network.get_adjacency_matrix('max_te_lag', fdr=False)
adj_mat.print_matrix()
assert adj_mat._weight_matrix[0, 1] == delay_1, (
'Estimate for delay 1 is not correct.')
assert adj_mat._weight_matrix[0, 2] == delay_2, (
'Estimate for delay 2 is not correct.')
assert adj_mat._weight_matrix[0, 3] == delay_3, (
'Estimate for delay 3 is not correct.')
for target in range(1, 4):
est_mi = res_network._single_target[target].omnibus_te
assert np.isclose(est_mi, expected_mi, atol=0.05), (
'Estimated TE for target {0} is not correct. Expected: {1}, '
'Actual results: {2}.'.format(target, expected_mi, est_mi))
"""Estimation from discrete data using IDTxl."""
import numpy as np
from idtxl.estimators_jidt import JidtDiscreteCMI, JidtDiscreteTE
from idtxl.idtxl_utils import calculate_mi
from idtxl.data import Data
from idtxl.multivariate_te import MultivariateTE
# 1 Use core esimtators with data discretisation. Generate Gaussian test data
# and call JIDT Discrete estimators using the build-in discretization.
n = 1000
covariance = 0.4
corr_expected = covariance / (1 * np.sqrt(covariance**2 + (1 - covariance)**2))
expected_mi = calculate_mi(corr_expected)
source_cor = np.random.normal(0, 1, size=n) # correlated src
source_uncor = np.random.normal(0, 1, size=n) # uncorrelated src
target = (covariance * source_cor +
(1 - covariance) * np.random.normal(0, 1, size=n))
settings = {'discretise_method': 'equal', 'n_discrete_bins': 5}
est = JidtDiscreteCMI(settings)
cmi = est.estimate(source_cor, target, source_uncor)
print('Estimated CMI: {0:.5f}, expected CMI: {1:.5f}'.format(cmi, expected_mi))
settings['history_target'] = 1
est = JidtDiscreteTE(settings)
te = est.estimate(source_cor[1:n], target[0:n - 1])
print('Estimated TE: {0:.5f}, expected TE: {1:.5f}'.format(te, expected_mi))
# 2 Use network inference algorithms on discrete data.
n_procs = 5
alphabet_size = 5
data = Data(np.random.randint(0, alphabet_size, size=(n, n_procs)),
