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))