def test_similarity_matrix_permutation(): dat = np.random.multivariate_normal([2, 6], [[.5, 2], [.5, 3]], 190) x = Adjacency(dat[:, 0]) y = Adjacency(dat[:, 1]) stats = x.similarity(y, perm_type='2d', n_permute=1000) assert (stats['correlation'] > .4) & (stats['correlation'] < .85) & (stats['p'] < .001) stats = x.similarity(y, perm_type=None) assert (stats['correlation'] > .4) & (stats['correlation'] < .85)
def test_cluster_mean(): test_dat = Adjacency(block_diag(np.ones((4, 4)), np.ones((4, 4)) * 2, np.ones((4, 4)) * 3), matrix_type='similarity') test_labels = np.concatenate([np.ones(4) * x for x in range(1, 4)]) out = test_dat.within_cluster_mean(clusters=test_labels) assert np.sum(np.array([1, 2, 3]) - np.array([out[x] for x in out])) == 0
def test_similarity_matrix_permutation(): dat = np.random.multivariate_normal([2, 6], [[0.5, 2], [0.5, 3]], 190) x = Adjacency(dat[:, 0]) y = Adjacency(dat[:, 1]) stats = x.similarity(y, perm_type="2d", n_permute=1000) assert ((stats["correlation"] > 0.4) & (stats["correlation"] < 0.85) & (stats["p"] < 0.001)) stats = x.similarity(y, perm_type=None) assert (stats["correlation"] > 0.4) & (stats["correlation"] < 0.85)
def test_read_and_write_directed(sim_adjacency_directed, tmpdir): sim_adjacency_directed.write(os.path.join(str(tmpdir.join("Test.csv"))), method="long") dat_directed2 = Adjacency(os.path.join(str(tmpdir.join("Test.csv"))), matrix_type="directed_flat") assert np.all(np.isclose(sim_adjacency_directed.data, dat_directed2.data)) # Load Path dat_directed2 = Adjacency(Path(tmpdir.join("Test.csv")), matrix_type="directed_flat") assert np.all(np.isclose(sim_adjacency_directed.data, dat_directed2.data))
def sim_adjacency_directed(): sim_directed = np.array([[1, 0.5, 0.3, 0.4], [0.8, 1, 0.2, 0.1], [0.7, 0.6, 1, 0.5], [0.85, 0.4, 0.3, 1]]) labels = ['v_%s' % (x+1) for x in range(sim_directed.shape[1])] return Adjacency(sim_directed, matrix_type='directed', labels=labels)
def sim_adjacency_single(): sim = np.random.multivariate_normal([0,0,0,0],[[1, 0.8, 0.1, 0.4], [0.8, 1, 0.6, 0.1], [0.1, 0.6, 1, 0.3], [0.4, 0.1, 0.3, 1]], 100) data = pairwise_distances(sim.T, metric='correlation') labels = ['v_%s' % (x+1) for x in range(sim.shape[1])] return Adjacency(data, labels=labels)
def test_write_multiple(sim_adjacency_multiple, tmpdir): sim_adjacency_multiple.write(os.path.join(str(tmpdir.join('Test.csv'))), method='long') dat_multiple2 = Adjacency(os.path.join(str(tmpdir.join('Test.csv'))), matrix_type='distance_flat') assert np.all(np.isclose(sim_adjacency_multiple.data, dat_multiple2.data)) # Test i/o for hdf5 sim_adjacency_multiple.write(os.path.join(str(tmpdir.join('test_write.h5')))) b = Adjacency(os.path.join(tmpdir.join('test_write.h5'))) for k in ['Y', 'matrix_type', 'is_single_matrix', 'issymmetric', 'data']: if k == 'data': assert np.allclose(b.__dict__[k], sim_adjacency_multiple.__dict__[k]) elif k == 'Y': assert all(b.__dict__[k].eq(sim_adjacency_multiple.__dict__[k]).values) else: assert b.__dict__[k] == sim_adjacency_multiple.__dict__[k]
def test_regression(): # Test Adjacency Regression m1 = block_diag(np.ones((4, 4)), np.zeros((4, 4)), np.zeros((4, 4))) m2 = block_diag(np.zeros((4, 4)), np.ones((4, 4)), np.zeros((4, 4))) m3 = block_diag(np.zeros((4, 4)), np.zeros((4, 4)), np.ones((4, 4))) Y = Adjacency(m1 * 1 + m2 * 2 + m3 * 3, matrix_type="similarity") X = Adjacency([m1, m2, m3], matrix_type="similarity") stats = Y.regress(X) assert np.allclose(stats["beta"], np.array([1, 2, 3])) # Test Design_Matrix Regression n = 10 d = Adjacency( [ block_diag( np.ones((4, 4)) + np.random.randn(4, 4) * 0.1, np.zeros( (8, 8))) for _ in range(n) ], matrix_type="similarity", ) X = Design_Matrix(np.ones(n)) stats = d.regress(X) out = stats["beta"].cluster_summary(clusters=["Group1"] * 4 + ["Group2"] * 8, summary="within") assert np.allclose( np.array([out["Group1"], out["Group2"]]), np.array([1, 0]), rtol=1e-01) # np.allclose(np.sum(stats['beta']-np.array([1,2,3])),0)
def test_social_relations_model(): data = Adjacency( np.array([ [np.nan, 8, 5, 10], [7, np.nan, 7, 6], [8, 7, np.nan, 5], [4, 5, 0, np.nan], ]), matrix_type="directed", ) data2 = data.append(data) results1 = data.social_relations_model() assert isinstance(data.social_relations_model(), pd.Series) assert isinstance(data2.social_relations_model(), pd.DataFrame) assert len(results1["actor_effect"]) == data.square_shape()[0] assert results1["relationship_effect"].shape == data.square_shape() np.testing.assert_approx_equal(results1["actor_variance"], 3.33, significant=2) np.testing.assert_approx_equal(results1["partner_variance"], 0.66, significant=2) np.testing.assert_approx_equal(results1["relationship_variance"], 3.33, significant=2) np.testing.assert_approx_equal(results1["actor_partner_correlation"], 0.22, significant=2) np.testing.assert_approx_equal(results1["dyadic_reciprocity_correlation"], 0.2, significant=2)
def test_regression(): # Test Adjacency Regression m1 = block_diag(np.ones((4, 4)), np.zeros((4, 4)), np.zeros((4, 4))) m2 = block_diag(np.zeros((4, 4)), np.ones((4, 4)), np.zeros((4, 4))) m3 = block_diag(np.zeros((4, 4)), np.zeros((4, 4)), np.ones((4, 4))) Y = Adjacency(m1 * 1 + m2 * 2 + m3 * 3, matrix_type='similarity') X = Adjacency([m1, m2, m3], matrix_type='similarity') stats = Y.regress(X) assert np.allclose(stats['beta'], np.array([1, 2, 3])) # Test Design_Matrix Regression n = 10 d = Adjacency([ block_diag( np.ones((4, 4)) + np.random.randn(4, 4) * .1, np.zeros((8, 8))) for x in range(n) ], matrix_type='similarity') X = Design_Matrix(np.ones(n)) stats = d.regress(X) out = stats['beta'].within_cluster_mean(clusters=['Group1'] * 4 + ['Group2'] * 8) assert np.allclose( np.array([out['Group1'], out['Group2']]), np.array([1, 0]), rtol=1e-01) # np.allclose(np.sum(stats['beta']-np.array([1,2,3])),0)
def test_write_multiple(sim_adjacency_multiple, tmpdir): sim_adjacency_multiple.write(os.path.join(str(tmpdir.join("Test.csv"))), method="long") dat_multiple2 = Adjacency(os.path.join(str(tmpdir.join("Test.csv"))), matrix_type="distance_flat") assert np.all(np.isclose(sim_adjacency_multiple.data, dat_multiple2.data)) # Test i/o for hdf5 sim_adjacency_multiple.write( os.path.join(str(tmpdir.join("test_write.h5")))) b = Adjacency(os.path.join(tmpdir.join("test_write.h5"))) for k in ["Y", "matrix_type", "is_single_matrix", "issymmetric", "data"]: if k == "data": assert np.allclose(b.__dict__[k], sim_adjacency_multiple.__dict__[k]) elif k == "Y": assert all(b.__dict__[k].eq( sim_adjacency_multiple.__dict__[k]).values) else: assert b.__dict__[k] == sim_adjacency_multiple.__dict__[k]
def sim_adjacency_multiple(): n = 10 sim = np.random.multivariate_normal([0,0,0,0],[[1, 0.8, 0.1, 0.4], [0.8, 1, 0.6, 0.1], [0.1, 0.6, 1, 0.3], [0.4, 0.1, 0.3, 1]], 100) data = pairwise_distances(sim.T, metric='correlation') dat_all = [] for t in range(n): tmp = data dat_all.append(tmp) labels = ['v_%s' % (x+1) for x in range(sim.shape[1])] return Adjacency(dat_all, labels=labels)
def test_cluster_summary(): m1 = block_diag(np.ones((4, 4)), np.zeros((4, 4)), np.zeros((4, 4))) m2 = block_diag(np.zeros((4, 4)), np.ones((4, 4)), np.zeros((4, 4))) m3 = block_diag(np.zeros((4, 4)), np.zeros((4, 4)), np.ones((4, 4))) noisy = (m1 * 1 + m2 * 2 + m3 * 3) + np.random.randn(12, 12) * 0.1 dat = Adjacency(noisy, matrix_type="similarity", labels=["C1"] * 4 + ["C2"] * 4 + ["C3"] * 4) clusters = [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3] cluster_mean = dat.cluster_summary(clusters=clusters) for i, j in zip(np.array([1, 2, 3]), np.array([cluster_mean[x] for x in cluster_mean])): np.testing.assert_almost_equal(i, j, decimal=1) for i in dat.cluster_summary(clusters=clusters, summary="between").values(): np.testing.assert_almost_equal(0, i, decimal=1) for i in dat.cluster_summary(clusters=clusters, summary="between").values(): np.testing.assert_almost_equal(0, i, decimal=1)
def test_directed_similarity(): dat = np.random.multivariate_normal([2, 6], [[.5, 2], [.5, 3]], 400) x = Adjacency(dat[:, 0].reshape(20, 20), matrix_type='directed') y = Adjacency(dat[:, 1].reshape(20, 20), matrix_type='directed') # Ignore diagonal stats = x.similarity(y, perm_type='1d', ignore_diagonal=True, n_permute=1000) assert (stats['correlation'] > .4) & (stats['correlation'] < .85) & (stats['p'] < .001) # Use diagonal stats = x.similarity(y, perm_type=None, ignore_diagonal=False) assert (stats['correlation'] > .4) & (stats['correlation'] < .85) # Error out but make usre TypeError is the reason why try: x.similarity(y, perm_type='2d') except TypeError as e: pass try: x.similarity(y, perm_type='jackknife') except TypeError as e: pass
def distance(self, method='euclidean', **kwargs): """ Calculate distance between rows within a Fex() instance. Args: method: type of distance metric (can use any scikit learn or sciypy metric) Returns: dist: Outputs a 2D distance matrix. """ return Adjacency(pairwise_distances(self, metric=method, **kwargs), matrix_type='Distance')
def test_directed_similarity(): dat = np.random.multivariate_normal([2, 6], [[0.5, 2], [0.5, 3]], 400) x = Adjacency(dat[:, 0].reshape(20, 20), matrix_type="directed") y = Adjacency(dat[:, 1].reshape(20, 20), matrix_type="directed") # Ignore diagonal stats = x.similarity(y, perm_type="1d", ignore_diagonal=True, n_permute=1000) assert ((stats["correlation"] > 0.4) & (stats["correlation"] < 0.85) & (stats["p"] < 0.001)) # Use diagonal stats = x.similarity(y, perm_type=None, ignore_diagonal=False) assert (stats["correlation"] > 0.4) & (stats["correlation"] < 0.85) # Error out but make usre TypeError is the reason why try: x.similarity(y, perm_type="2d") except TypeError as _: # noqa pass
# visualize which regions are more central in this analysis. from sklearn.metrics import pairwise_distances from nltools.data import Adjacency from nltools.mask import roi_to_brain import pandas as pd import numpy as np sub_list = data.X['SubjectID'].unique() # perform matrix multiplication to compute linear contrast for each subject lin_contrast = [] for sub in sub_list: lin_contrast.append(data[data.X['SubjectID'] == sub] * np.array([1, -1, 0])) # concatenate list of Brain_Data instances into a single instance lin_contrast = Brain_Data(lin_contrast) # Compute correlation distance between each ROI dist = Adjacency(pairwise_distances(lin_contrast.extract_roi(mask), metric='correlation'), matrix_type='distance') # Threshold functional connectivity and convert to Adjacency Matrix. Plot as heatmap dist.threshold(upper=.4, binarize=True).plot() # Convert Adjacency matrix to networkX instance g = dist.threshold(upper=.4, binarize=True).to_graph() # Compute degree centrality and convert back into Brain_Data instance. degree_centrality = roi_to_brain(pd.Series(dict(g.degree())), mask_x) degree_centrality.plot()
def test_append(sim_adjacency_single): a = Adjacency() a = a.append(sim_adjacency_single) assert a.shape() == sim_adjacency_single.shape() a = a.append(a) assert a.shape() == (2, 6)
for i in labels]) == 'threat').astype(int) unique_run = np.array([ re.search('(?<=-d)[12]', i).group() + re.search('(?<=_Run-)[0-9]', i).group() for i in beta_map_fnames_ordered ]).astype(float) for n, i in enumerate(np.unique(unique_run)): unique_run[unique_run == i] = n # Set up RSMs # # Covariates # # Matrix representing the unique run - used to ensure we ignore trials from the same run unique_run_matrix = distance_matrix(unique_run[now_or_later, np.newaxis], unique_run[now_or_later, np.newaxis]) == 0 unique_run_matrix = Adjacency(unique_run_matrix) # Session session_matrix = distance_matrix( np.array(sessions).astype(float)[now_or_later, np.newaxis], np.array(sessions).astype(float)[now_or_later, np.newaxis]) plt.figure(figsize=(8, 8), dpi=100) sns.heatmap(session_matrix, square=True) session_matrix = Adjacency(session_matrix, matrix_type='similarity') session_matrix.data = scale(session_matrix.data) # Run run_matrix = distance_matrix( np.array(runs).astype(float)[now_or_later, np.newaxis], np.array(runs).astype(float)[now_or_later, np.newaxis]) == 0 plt.figure(figsize=(8, 8), dpi=100)
def test_sum(): n = 10 a = Adjacency(np.ones((n, n)), matrix_type="directed") assert a.sum() == n**2 a = Adjacency([a, a]) assert a.sum().data.sum() == (n**2) * 2 a = Adjacency(np.ones((n, n)), matrix_type="similarity") assert a.sum() == n * (n - 1) / 2 a = Adjacency([a, a]) assert a.sum().data.sum() == n * (n - 1) a = Adjacency(np.ones((n, n)), matrix_type="distance") assert a.sum() == n * (n - 1) / 2 a = Adjacency([a, a]) assert a.sum().data.sum() == n * (n - 1)
# In[37]: roi_corr = 1 - pairwise_distances(rois, metric='correlation') sns.heatmap(roi_corr, square=True, vmin=-1, vmax=1, cmap='RdBu_r') # Now we need to convert this correlation matrix into a graph and calculate a centrality measure. We will use the `Adjacency` class from nltools as it has many functions that are useful for working with this type of data, including casting these type of matrices into networkx graph objects. # # We will be using the [networkx](https://networkx.github.io/documentation/stable/) python toolbox to work with graphs and compute different metrics of the graph. # # Let's calculate degree centrality, which is the total number of nodes each node is connected with. Unfortunately, many graph theory metrics require working with adjacency matrices, which are binary matrices indicating the presence of an edge or not. To create this, we will simply apply an arbitrary threshold to our correlation matrix. # In[38]: a = Adjacency(roi_corr, matrix_type='similarity', labels=[x for x in range(50)]) a_thresholded = a.threshold(upper=.6, binarize=True) a_thresholded.plot() # Okay, now that we have a thresholded binary matrix, let's cast our data into a networkx object and calculate the degree centrality of each ROI and make a quick plot of the graph. # In[41]: plt.figure(figsize=(20, 15)) G = a_thresholded.to_graph() pos = nx.kamada_kawai_layout(G) node_and_degree = G.degree() nx.draw_networkx_edges(G, pos, width=3, alpha=.2) nx.draw_networkx_labels(G, pos, font_size=14, font_color='darkslategray')
def test_adjacency(tmpdir): n = 10 sim = np.random.multivariate_normal([0,0,0,0],[[1, 0.8, 0.1, 0.4], [0.8, 1, 0.6, 0.1], [0.1, 0.6, 1, 0.3], [0.4, 0.1, 0.3, 1]], 100) data = pairwise_distances(sim.T, metric='correlation') dat_all = [] for t in range(n): tmp = data dat_all.append(tmp) sim_directed = np.array([[1, 0.5, 0.3, 0.4], [0.8, 1, 0.2, 0.1], [0.7, 0.6, 1, 0.5], [0.85, 0.4, 0.3, 1]]) labels = ['v_%s' % (x+1) for x in range(sim.shape[1])] dat_single = Adjacency(dat_all[0], labels=labels) dat_multiple = Adjacency(dat_all, labels=labels) dat_directed = Adjacency(sim_directed, matrix_type='directed', labels=labels) # Test automatic distance/similarity detection assert dat_single.matrix_type is 'distance' dat_single2 = Adjacency(1-data) assert dat_single2.matrix_type is 'similarity' assert not dat_directed.issymmetric assert dat_single.issymmetric # Test length assert len(dat_multiple) == dat_multiple.data.shape[0] assert len(dat_multiple[0]) == 1 # Test Indexing assert len(dat_multiple[0]) == 1 assert len(dat_multiple[0:4]) == 4 assert len(dat_multiple[0, 2, 3]) == 3 # Test basic arithmetic assert(dat_directed+5).data[0] == dat_directed.data[0]+5 assert(dat_directed-.5).data[0] == dat_directed.data[0]-.5 assert(dat_directed*5).data[0] == dat_directed.data[0]*5 assert np.all(np.isclose((dat_directed+dat_directed).data, (dat_directed*2).data)) assert np.all(np.isclose((dat_directed*2-dat_directed).data, dat_directed.data)) # Test copy assert np.all(dat_multiple.data == dat_multiple.copy().data) # Test squareform & iterable assert len(dat_multiple.squareform()) == len(dat_multiple) assert dat_single.squareform().shape == data.shape assert dat_directed.squareform().shape == sim_directed.shape # Test write dat_multiple.write(os.path.join(str(tmpdir.join('Test.csv'))), method='long') dat_multiple2 = Adjacency(os.path.join(str(tmpdir.join('Test.csv'))), matrix_type='distance_flat') dat_directed.write(os.path.join(str(tmpdir.join('Test.csv'))), method='long') dat_directed2 = Adjacency(os.path.join(str(tmpdir.join('Test.csv'))), matrix_type='directed_flat') assert np.all(np.isclose(dat_multiple.data, dat_multiple2.data)) assert np.all(np.isclose(dat_directed.data, dat_directed2.data)) # Test mean assert isinstance(dat_multiple.mean(axis=0), Adjacency) assert len(dat_multiple.mean(axis=0)) == 1 assert len(dat_multiple.mean(axis=1)) == len(np.mean(dat_multiple.data, axis=1)) # Test std assert isinstance(dat_multiple.std(axis=0), Adjacency) assert len(dat_multiple.std(axis=0)) == 1 assert len(dat_multiple.std(axis=1)) == len(np.std(dat_multiple.data, axis=1)) # Test similarity assert len(dat_multiple.similarity( dat_single.squareform())) == len(dat_multiple) assert len(dat_multiple.similarity(dat_single.squareform(), metric='pearson')) == len(dat_multiple) assert len(dat_multiple.similarity(dat_single.squareform(), metric='kendall')) == len(dat_multiple) # Test distance assert isinstance(dat_multiple.distance(), Adjacency) assert dat_multiple.distance().square_shape()[0] == len(dat_multiple) # Test ttest mn, p = dat_multiple.ttest() assert len(mn) == 1 assert len(p) == 1 assert mn.shape()[0] == dat_multiple.shape()[1] assert p.shape()[0] == dat_multiple.shape()[1] # Test Threshold assert np.sum(dat_directed.threshold(upper=.8).data == 0) == 10 assert dat_directed.threshold(upper=.8, binarize=True).data[0] assert np.sum(dat_directed.threshold(upper='70%', binarize=True).data) == 5 assert np.sum(dat_directed.threshold(lower=.4, binarize=True).data) == 6 # Test to_graph() assert isinstance(dat_directed.to_graph(), nx.DiGraph) assert isinstance(dat_single.to_graph(), nx.Graph) # Test Append a = Adjacency() a = a.append(dat_single) assert a.shape() == dat_single.shape() a = a.append(a) assert a.shape() == (2, 6) n_samples = 3 b = dat_multiple.bootstrap('mean', n_samples=n_samples) assert isinstance(b['Z'], Adjacency) b = dat_multiple.bootstrap('std', n_samples=n_samples) assert isinstance(b['Z'], Adjacency) # Test plot f = dat_single.plot() assert isinstance(f, plt.Figure) f = dat_multiple.plot() assert isinstance(f, plt.Figure) # Test plot_mds f = dat_single.plot_mds() assert isinstance(f, plt.Figure)
Now that we have specified our 50 nodes, we need to calculate the edges of the graph. We will be using pearson correlations. We will be using the `pairwise_distances` function from scikit-learn as it is much faster than most other correlation measures. We will then convert the distance metric into similarities by subtracting all of the values from 1. Let's visualize the resulting correlation matrix as a heatmap using seaborn. roi_corr = 1 - pairwise_distances(rois, metric='correlation') sns.heatmap(roi_corr, square=True, vmin=-1, vmax=1, cmap='RdBu_r') Now we need to convert this correlation matrix into a graph and calculate a centrality measure. We will use the `Adjacency` class from nltools as it has many functions that are useful for working with this type of data, including casting these type of matrices into networkx graph objects. We will be using the [networkx](https://networkx.github.io/documentation/stable/) python toolbox to work with graphs and compute different metrics of the graph. Let's calculate degree centrality, which is the total number of nodes each node is connected with. Unfortunately, many graph theory metrics require working with adjacency matrices, which are binary matrices indicating the presence of an edge or not. To create this, we will simply apply an arbitrary threshold to our correlation matrix. a = Adjacency(roi_corr, matrix_type='similarity', labels=[x for x in range(50)]) a_thresholded = a.threshold(upper=.6, binarize=True) a_thresholded.plot() Okay, now that we have a thresholded binary matrix, let's cast our data into a networkx object and calculate the degree centrality of each ROI and make a quick plot of the graph. plt.figure(figsize=(20,15)) G = a_thresholded.to_graph() pos = nx.kamada_kawai_layout(G) node_and_degree = G.degree() nx.draw_networkx_edges(G, pos, width=3, alpha=.2) nx.draw_networkx_labels(G, pos, font_size=14, font_color='darkslategray') nx.draw_networkx_nodes(G, pos, nodelist=list(dict(node_and_degree).keys()), node_size=[x[1]*100 for x in node_and_degree],
######################################################################### # Load Data # ---------- # # Similar to the Brain_Data class, Adjacency instances can be initialized by passing in a numpy array or pandas data frame, or a path to a csv file or list of files. Here we will generate some fake data to demonstrate how to use this class. In addition to data, you must indicate the type of matrix. Currently, you can specify `['similarity','distance','directed']`. Similarity matrices are symmetrical with typically ones along diagonal, Distance matrices are symmetrical with zeros along diagonal, and Directed graph matrices are not symmetrical. Symmetrical matrices only store the upper triangle. The Adjacency class can also accommodate labels, but does not require them. from nltools.data import Adjacency from scipy.linalg import block_diag import numpy as np m1 = block_diag(np.ones((4, 4)), np.zeros((4, 4)), np.zeros((4, 4))) m2 = block_diag(np.zeros((4, 4)), np.ones((4, 4)), np.zeros((4, 4))) m3 = block_diag(np.zeros((4, 4)), np.zeros((4, 4)), np.ones((4, 4))) * 3 noisy = (m1 * 1 + m2 * 2 + m3 * 3) + np.random.randn(12, 12) * .1 dat = Adjacency(noisy, matrix_type='similarity', labels=['C1'] * 4 + ['C2'] * 4 + ['C3'] * 4) ######################################################################### # Basic information about the object can be viewed by simply calling it. print(dat) ######################################################################### # Adjacency objects can easily be converted back into two-dimensional matrices with the `.squareform()` method. dat.squareform() ######################################################################### # Matrices can viewed as a heatmap using the `.plot()` method.
def test_write_multiple(sim_adjacency_multiple, tmpdir): sim_adjacency_multiple.write(os.path.join(str(tmpdir.join('Test.csv'))), method='long') dat_multiple2 = Adjacency(os.path.join(str(tmpdir.join('Test.csv'))), matrix_type='distance_flat') assert np.all(np.isclose(sim_adjacency_multiple.data, dat_multiple2.data))
def test_write_directed(sim_adjacency_directed, tmpdir): sim_adjacency_directed.write(os.path.join(str(tmpdir.join('Test.csv'))), method='long') dat_directed2 = Adjacency(os.path.join(str(tmpdir.join('Test.csv'))), matrix_type='directed_flat') assert np.all(np.isclose(sim_adjacency_directed.data, dat_directed2.data))
def test_type_single(sim_adjacency_single): assert sim_adjacency_single.matrix_type == "distance" dat_single2 = Adjacency(1 - sim_adjacency_single.squareform()) assert dat_single2.matrix_type == "similarity" assert sim_adjacency_single.issymmetric
# ### Testing a Representation Hypothesis # # Ok, now that we have a sense of what the similarity of patterns look like in left motor cortex, let's create an adjacency matrix indicating a specific relationship between left hand finger tapping across the auditory and visual conditions. This type of adjacency matrix is one way in which we can test a specific hypotheses about the representational structure of the data across all images. # # As you can see this only includes edges for the motor-left auditory and motor-left visual conditions. # In[109]: motor = np.zeros((len(conditions), len(conditions))) motor[np.diag_indices(len(conditions))] = 1 motor[1, 7] = 1 motor[7, 1] = 1 motor[2, 8] = 1 motor[8, 2] = 1 motor = Adjacency(motor, matrix_type='distance', labels=conditions) motor.plot() # Now let's search over all ROIs to see if any match this representational structure of left motor-cortex using the `similarity()` method from the `Adjacency` class. This function uses spearman rank correlations by default. This is probably a good idea as we are most interested in monotonic relationships between the two similarity matrices. # # The `similarity()` method also computes permutations within columns and rows by default. To speed up the analysis, we will set the number of permutations to zero (i.e., `n_permute=0`). # In[110]: motor_sim_r = [] for m in out_sim: s = m.similarity(motor, metric='spearman', n_permute=0) motor_sim_r.append(s['correlation']) # This will return a vector of similarity scores for each ROI, we can plot the distribution of these 50 $\rho$ values.
######################################################################### # Load Data # ---------- # # Similar to the Brain_Data class, Adjacency instances can be initialized by passing in a numpy array or pandas data frame, or a path to a csv file or list of files. Here we will generate some fake data to demonstrate how to use this class. In addition to data, you must indicate the type of matrix. Currently, you can specify `['similarity','distance','directed']`. Similarity matrices are symmetrical with typically ones along diagonal, Distance matrices are symmetrical with zeros along diagonal, and Directed graph matrices are not symmetrical. Symmetrical matrices only store the upper triangle. The Adjacency class can also accommodate labels, but does not require them. from nltools.data import Adjacency from scipy.linalg import block_diag import numpy as np m1 = block_diag(np.ones((4, 4)), np.zeros((4, 4)), np.zeros((4, 4))) m2 = block_diag(np.zeros((4, 4)), np.ones((4, 4)), np.zeros((4, 4))) m3 = block_diag(np.zeros((4, 4)), np.zeros((4, 4)), np.ones((4, 4))) noisy = (m1 * 1 + m2 * 2 + m3 * 3) + np.random.randn(12, 12) * 0.1 dat = Adjacency(noisy, matrix_type="similarity", labels=["C1"] * 4 + ["C2"] * 4 + ["C3"] * 4) ######################################################################### # Basic information about the object can be viewed by simply calling it. print(dat) ######################################################################### # Adjacency objects can easily be converted back into two-dimensional matrices with the `.squareform()` method. dat.squareform() ######################################################################### # Matrices can viewed as a heatmap using the `.plot()` method.