def test_analyse_single_target(): """Test call to network_analysis method.""" n = 50 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) dat = Data(np.vstack((x, y, z)), 'ps', normalise=False) # Run Tartu estimator settings = {'pid_estimator': 'TartuPID', 'tail': 'two', 'lags': [0, 0]} pid = PartialInformationDecomposition() est_tartu = pid.analyse_single_target(settings=settings, data=dat, target=2, sources=[0, 1]) assert 0.9 < est_tartu['syn_s1_s2'] <= 1.1, ( 'Tartu estimator incorrect synergy: {0}, should approx. 1'.format( est_tartu['syn_s1_s2'])) assert est_tartu['unq_s1'] < 0.1, ('Tartu estimator incorrect unique ' 's1: {0}, should approx. 0'.format( est_tartu['unq_s1'])) assert est_tartu['unq_s2'] < 0.1, ('Tartu estimator incorrect unique ' 's2: {0}, should approx. 0'.format( est_tartu['unq_s2']))
def test_analyse_single_target(): """Test call to network_analysis method.""" n = 100 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) data = Data(np.vstack((x, y, z)), 'ps', normalise=False) # Run Tartu estimator pid = PartialInformationDecomposition() settings = {'pid_estimator': 'TartuPID', 'tail': 'two', 'lags_pid': [0, 0]} est_tartu = pid.analyse_single_target(settings=settings, data=data, target=2, sources=[0, 1]) assert 0.9 < est_tartu._single_target[2]['syn_s1_s2'] <= 1.1, ( 'Tartu estimator incorrect synergy: {0}, should approx. 1'.format( est_tartu._single_target[2]['syn_s1_s2'])) assert est_tartu._single_target[2]['unq_s1'] < 0.1, ( 'Tartu estimator incorrect unique s1: {0}, should approx. 0'.format( est_tartu._single_target[2]['unq_s1'])) assert est_tartu._single_target[2]['unq_s2'] < 0.1, ( 'Tartu estimator incorrect unique s2: {0}, should approx. 0'.format( est_tartu._single_target[2]['unq_s2'])) # Run Sydney estimator settings = { 'pid_estimator': 'SydneyPID', 'alph_s1': alph, 'alph_s2': alph, 'alph_t': alph, 'max_unsuc_swaps_row_parm': 60, 'num_reps': 63, 'max_iters': 1000, 'pid_estimator': 'SydneyPID', 'lags_pid': [0, 0] } est_sydney = pid.analyse_single_target(settings=settings, data=data, target=2, sources=[0, 1]) assert 0.9 < est_sydney._single_target[2]['syn_s1_s2'] <= 1.1, ( 'Sydney estimator incorrect synergy: {0}, should approx. 1'.format( est_sydney._single_target[2]['syn_s1_s2'])) assert est_sydney._single_target[2]['unq_s1'] < 0.1, ( 'Sydney estimator incorrect unique s1: {0}, should approx. 0'.format( est_sydney._single_target[2]['unq_s1'])) assert est_sydney._single_target[2]['unq_s2'] < 0.1, ( 'Sydney estimator incorrect unique s2: {0}, should approx. 0'.format( est_sydney._single_target[2]['unq_s2']))
def test_analyse_single_target(): """Test call to network_analysis method.""" n = 100 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) data = Data(np.vstack((x, y, z)), 'ps', normalise=False) # Run Tartu estimator pid = PartialInformationDecomposition() settings = {'pid_estimator': 'TartuPID', 'tail': 'two', 'lags_pid': [0, 0]} est_tartu = pid.analyse_single_target(settings=settings, data=data, target=2, sources=[0, 1]) assert 0.9 < est_tartu._single_target[2]['syn_s1_s2'] <= 1.1, ( 'Tartu estimator incorrect synergy: {0}, should approx. 1'.format( est_tartu._single_target[2]['syn_s1_s2'])) assert est_tartu._single_target[2]['unq_s1'] < 0.1, ( 'Tartu estimator incorrect unique s1: {0}, should approx. 0'.format( est_tartu._single_target[2]['unq_s1'])) assert est_tartu._single_target[2]['unq_s2'] < 0.1, ( 'Tartu estimator incorrect unique s2: {0}, should approx. 0'.format( est_tartu._single_target[2]['unq_s2'])) # Run Sydney estimator settings = {'pid_estimator': 'SydneyPID', 'alph_s1': alph, 'alph_s2': alph, 'alph_t': alph, 'max_unsuc_swaps_row_parm': 60, 'num_reps': 63, 'max_iters': 1000, 'pid_estimator': 'SydneyPID', 'lags_pid': [0, 0]} est_sydney = pid.analyse_single_target(settings=settings, data=data, target=2, sources=[0, 1]) assert 0.9 < est_sydney._single_target[2]['syn_s1_s2'] <= 1.1, ( 'Sydney estimator incorrect synergy: {0}, should approx. 1'.format( est_sydney._single_target[2]['syn_s1_s2'])) assert est_sydney._single_target[2]['unq_s1'] < 0.1, ( 'Sydney estimator incorrect unique s1: {0}, should approx. 0'.format( est_sydney._single_target[2]['unq_s1'])) assert est_sydney._single_target[2]['unq_s2'] < 0.1, ( 'Sydney estimator incorrect unique s2: {0}, should approx. 0'.format( est_sydney._single_target[2]['unq_s2']))
# Import classes import numpy as np from idtxl.partial_information_decomposition import ( PartialInformationDecomposition) from idtxl.data import Data # a) Generate test data n = 100 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) data = Data(np.vstack((x, y, z)), 'ps', normalise=False) # b) Initialise analysis object and define settings for both PID estimators pid = PartialInformationDecomposition() settings_tartu = {'pid_estimator': 'TartuPID', 'lags_pid': [0, 0]} settings_sydney = { 'alph_s1': alph, 'alph_s2': alph, 'alph_t': alph, 'max_unsuc_swaps_row_parm': 60, 'num_reps': 63, 'max_iters': 1000, 'pid_estimator': 'SydneyPID', 'lags_pid': [0, 0] } # c) Run Tartu estimator results_tartu = pid.analyse_single_target(settings=settings_tartu, data=data,
def test_pid_user_input(): """Test if user input is handled correctly.""" # Test missing estimator name pid = PartialInformationDecomposition() with pytest.raises(RuntimeError): pid.analyse_single_target(settings={}, data=Data(), target=0, sources=[1, 2]) # Test wrong estimator name settings = {'pid_estimator': 'TestPID'} with pytest.raises(RuntimeError): pid.analyse_single_target(settings=settings, data=Data(), target=0, sources=[1, 2]) # Test default lags for network_analysis settings = {'pid_estimator': 'TartuPID'} dat = Data(np.random.randint(0, 10, size=(5, 100)), dim_order='ps', normalise=False) res = pid.analyse_network(settings=settings, data=dat, targets=[0, 1, 2], sources=[[1, 3], [2, 4], [0, 1]]) assert np.all(res[0]['settings']['lags'] == [1, 1]), ( 'Lags were not set to default.') assert np.all(res[1]['settings']['lags'] == [1, 1]), ( 'Lags were not set to default.') assert np.all(res[2]['settings']['lags'] == [1, 1]), ( 'Lags were not set to default.') n = 20 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) dat = Data(np.vstack((x, y, z)), 'ps', normalise=False) # Test two-tailed significance test settings = {'pid_estimator': 'TartuPID', 'tail': 'two', 'lags': [0, 0]} pid = PartialInformationDecomposition() with pytest.raises(RuntimeError): # Test incorrect number of sources pid.analyse_single_target(settings=settings, data=dat, target=2, sources=[1, 2, 3]) settings['lags'] = [0, 0, 0] with pytest.raises(RuntimeError): # Test incorrect number of lags pid.analyse_single_target(settings=settings, data=dat, target=2, sources=[1, 3]) settings['lags'] = [n * 3, 0] with pytest.raises(RuntimeError): # Test lag > no. samples pid.analyse_single_target(settings=settings, data=dat, target=2, sources=[0, 1]) settings['lags'] = [n, 0] with pytest.raises(RuntimeError): # Test lag == no. samples pid.analyse_single_target(settings=settings, data=dat, target=2, sources=[0, 1]) settings['lags'] = [0, 0] with pytest.raises(RuntimeError): # Test target in sources pid.analyse_single_target(settings=settings, data=dat, target=2, sources=[2, 3]) with pytest.raises(IndexError): # Test target not in processes pid.analyse_single_target(settings=settings, data=dat, target=5, sources=[0, 1])
def test_pid_xor_data(): """Test basic calls to PID class.""" n = 100 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) data = Data(np.vstack((x, y, z)), 'ps', normalise=False) # Run Tartu estimator settings = {'pid_estimator': 'TartuPID', 'lags_pid': [0, 0]} pid = PartialInformationDecomposition() tic = tm.time() est_tartu = pid.analyse_single_target(settings, data=data, target=2, sources=[0, 1]) t_tartu = tm.time() - tic # Run Sydney estimator settings = { 'n_perm': 11, 'alpha': 0.1, 'alph_s1': alph, 'alph_s2': alph, 'alph_t': alph, 'max_unsuc_swaps_row_parm': 60, 'num_reps': 63, 'max_iters': 1000, 'pid_estimator': 'SydneyPID', 'lags_pid': [0, 0]} pid = PartialInformationDecomposition() tic = tm.time() est_sydney = pid.analyse_single_target(settings, data=data, target=2, sources=[0, 1]) t_sydney = tm.time() - tic print('\nResults Tartu estimator:') utils.print_dict(est_tartu.get_single_target(2)) print('\nResults Sydney estimator:') utils.print_dict(est_sydney.get_single_target(2)) print('\nLogical XOR') print('Estimator Sydney\t\tTartu\n') print('PID evaluation {:.3f} s\t\t{:.3f} s\n'.format(t_sydney, t_tartu)) print('Uni s1 {0:.8f}\t\t{1:.8f}'.format( est_sydney._single_target[2]['unq_s1'], est_tartu._single_target[2]['unq_s1'])) print('Uni s2 {0:.8f}\t\t{1:.8f}'.format( est_sydney._single_target[2]['unq_s2'], est_tartu._single_target[2]['unq_s2'])) print('Shared s1_s2 {0:.8f}\t\t{1:.8f}'.format( est_sydney._single_target[2]['shd_s1_s2'], est_tartu._single_target[2]['shd_s1_s2'])) print('Synergy s1_s2 {0:.8f}\t\t{1:.8f}'.format( est_sydney._single_target[2]['syn_s1_s2'], est_tartu._single_target[2]['syn_s1_s2'])) assert 0.9 < est_sydney._single_target[2]['syn_s1_s2'] <= 1.1, ( 'Sydney estimator incorrect synergy: {0}, should approx. 1'.format( est_sydney._single_target[2]['syn_s1_s2'])) assert 0.9 < est_tartu._single_target[2]['syn_s1_s2'] <= 1.1, ( 'Tartu estimator incorrect synergy: {0}, should approx. 1'.format( est_tartu._single_target[2]['syn_s1_s2']))
def test_pid_user_input(): """Test if user input is handled correctly.""" # Test missing estimator name pid = PartialInformationDecomposition() with pytest.raises(RuntimeError): pid.analyse_single_target(settings={}, data=Data(), target=0, sources=[1, 2]) # Test wrong estimator name settings = {'pid_estimator': 'TestPID'} with pytest.raises(RuntimeError): pid.analyse_single_target(settings=settings, data=Data(), target=0, sources=[1, 2]) # Test default lags for network_analysis settings = {'pid_estimator': 'TartuPID'} data = Data(np.random.randint(0, 10, size=(5, 100)), dim_order='ps', normalise=False) results = pid.analyse_network(settings=settings, data=data, targets=[0, 1, 2], sources=[[1, 3], [2, 4], [0, 1]]) assert np.all(results.settings['lags_pid'] == [1, 1]), ( 'Lags were not set to default.') n = 20 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) data = Data(np.vstack((x, y, z)), 'ps', normalise=False) # Test two-tailed significance test settings = {'pid_estimator': 'TartuPID', 'tail': 'two', 'lags_pid': [0, 0]} pid = PartialInformationDecomposition() with pytest.raises(RuntimeError): # Test incorrect number of sources pid.analyse_single_target(settings=settings, data=data, target=2, sources=[1, 2, 3]) settings['lags_pid'] = [0, 0, 0] with pytest.raises(RuntimeError): # Test incorrect number of lags pid.analyse_single_target(settings=settings, data=data, target=2, sources=[1, 3]) settings['lags_pid'] = [n * 3, 0] with pytest.raises(RuntimeError): # Test lag > no. samples pid.analyse_single_target(settings=settings, data=data, target=2, sources=[0, 1]) settings['lags_pid'] = [n, 0] with pytest.raises(RuntimeError): # Test lag == no. samples pid.analyse_single_target(settings=settings, data=data, target=2, sources=[0, 1]) settings['lags_pid'] = [0, 0] with pytest.raises(RuntimeError): # Test target in sources pid.analyse_single_target(settings=settings, data=data, target=2, sources=[2, 3]) with pytest.raises(IndexError): # Test target not in processes pid.analyse_single_target(settings=settings, data=data, target=5, sources=[0, 1])
# Import classes import numpy as np from idtxl.partial_information_decomposition import ( PartialInformationDecomposition) from idtxl.data import Data # a) Generate test data n = 100 alph = 2 x = np.random.randint(0, alph, n) y = np.random.randint(0, alph, n) z = np.logical_xor(x, y).astype(int) data = Data(np.vstack((x, y, z)), 'ps', normalise=False) # b) Initialise analysis object and define settings for both PID estimators pid = PartialInformationDecomposition() settings_tartu = {'pid_estimator': 'TartuPID', 'lags_pid': [0, 0]} settings_sydney = { 'alph_s1': alph, 'alph_s2': alph, 'alph_t': alph, 'max_unsuc_swaps_row_parm': 60, 'num_reps': 63, 'max_iters': 1000, 'pid_estimator': 'SydneyPID', 'lags_pid': [0, 0]} # c) Run Tartu estimator results_tartu = pid.analyse_single_target( settings=settings_tartu, data=data, target=2, sources=[0, 1])