def test_rdm_correlation_spearman(self): rdm1 = np.random.rand(8, 8) rdm2 = np.random.rand(8, 8) rp = rdm_correlation_spearman(rdm1, rdm2, permutation=True) self.assertEqual(len(rp), 2) rp = rdm_correlation_spearman(rdm1, rdm2, permutation=False) self.assertEqual(len(rp), 2) rdm1 = np.random.rand(8, 7) rp = rdm_correlation_spearman(rdm1, rdm2) self.assertEqual(rp, "Invalid input!")
def rdms_corr(demo_rdm, eeg_rdms, method="spearman", fisherz=False, rescale=False, permutation=False, iter=5000): """ Calculate the similarity between RDMs based on RDMs of EEG-like data and a demo RDM Parameters ---------- demo_rdm : array [n_cons, n_cons] A demo RDM. eeg_rdms : array The EEG/MEG/fNIRS/ECoG/sEEG/electrophysiological RDM(s). The shape can be [n_cons, n_cons] or [n1, n_cons, n_cons] or [n1, n2, n_cons, n_cons] or [n1, n2, n3, n_cons, n_cons]. ni(i=1, 2, 3) can be int(n_ts/timw_win), n_chls, n_subs. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. fisherz : bool True or False. Default is False. Do the Fisher-Z transform of the RDMs or not. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. permutation : bool True or False. Default is False. Use permutation test or not. iter : int. Default is 5000. The times for iteration. Returns ------- corrs : array The similarities between EEG/MEG/fNIRS/ECoG/sEEG/electrophysiological RDMs and a demo RDM If the shape of eeg_rdms is [n_cons, n_cons], the shape of corrs will be [2]. If the shape of eeg_rdms is [n1, n_cons, n_cons], the shape of corrs will be [n1, 2]. If the shape of eeg_rdms is [n1, n2, n_cons, n_cons], the shape of corrs will be [n1, n2, 2]. If the shape of eeg_rdms is [n1, n2, n3, n_cons, n_cons], the shape of corrs will be [n1, n2, n3, 2]. ni(i=1, 2, 3) can be int(n_ts/timw_win), n_chls, n_subs. 2 represents a r-value and a p-value. """ if len(np.shape(demo_rdm)) != 2 or len(np.shape(eeg_rdms)) < 2 or len(np.shape(eeg_rdms)) > 5 or \ np.shape(demo_rdm)[0] != np.shape(demo_rdm)[1] or np.shape(eeg_rdms)[-1] != np.shape(eeg_rdms)[-2]: return "Invalid input!" if len(eeg_rdms.shape) == 5: n1, n2, n3 = eeg_rdms.shape[:3] # initialize the corrs corrs = np.zeros([n1, n2, n3, 2], dtype=np.float64) # calculate the corrs for i in range(n1): for j in range(n2): for k in range(n3): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman( demo_rdm, eeg_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson( demo_rdm, eeg_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall( demo_rdm, eeg_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(demo_rdm, eeg_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(demo_rdm, eeg_rdms[i, j, k], rescale=rescale) return corrs if len(eeg_rdms.shape) == 4: n1, n2 = eeg_rdms.shape[:2] # initialize the corrs corrs = np.zeros([n1, n2, 2], dtype=np.float64) # calculate the corrs for i in range(n1): for j in range(n2): if method == "spearman": corrs[i, j] = rdm_correlation_spearman( demo_rdm, eeg_rdms[i, j], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i, j], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i, j], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(demo_rdm, eeg_rdms[i, j], rescale=rescale) return corrs if len(eeg_rdms.shape) == 3: n1 = eeg_rdms.shape[0] # initialize the corrs corrs = np.zeros([n1, 2], dtype=np.float64) # calculate the corrs for i in range(n1): if method == "spearman": corrs[i] = rdm_correlation_spearman(demo_rdm, eeg_rdms[i], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, 0] = rdm_similarity(demo_rdm, eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(demo_rdm, eeg_rdms[i], rescale=rescale) return corrs # initialize the corrs corr = np.zeros([2], dtype=np.float64) # calculate the corrs if method == "spearman": corr = rdm_correlation_spearman(demo_rdm, eeg_rdms, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corr = rdm_correlation_pearson(demo_rdm, eeg_rdms, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corr = rdm_correlation_kendall(demo_rdm, eeg_rdms, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corr[0] = rdm_similarity(demo_rdm, eeg_rdms, rescale=rescale) elif method == "distance": corr[0] = rdm_distance(demo_rdm, eeg_rdms, rescale=rescale) return corr
def ctsimilarities_cal(RDMs, method='spearman', fisherz=True): """ Calculate the Cross-Temporal Similarities based on normal RDMs Parameters ---------- RDMs : array The Representational Dissimilarity Matrices in time series. The shape could be [n_ts, n_conditions, n_conditions] or [n_subs, n_ts, n_conditions, n_conditions] or [n_channels, n_ts, n_conditions, n_conditions] or [n_subs, n_channels, n_ts, n_conditions, n_conditions]. n_ts, n_conditions, n_subs, n_channels represent the number of time-points, the number of conditions, the number of subjects and the number of channels, respectively. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. fisherz : bool True or False. Default is False. Do the Fisher-Z transform of the CTRDMs or not. Only when method='spearman' or 'pearson' or 'kendall', it works. Returns ------- CTSimilarities : array Cross-temporal similarities. If the shape of RDMs is [n_ts, n_conditions, n_conditions] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_ts, n_ts, 2]. If the shape of RDMs is [n_subs, n_ts, n_conditions, n_conditions] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_subs, n_ts, n_ts, 2]. If the shape of RDMs is [n_channels, n_ts, n_conditions, n_conditions] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_channels, n_ts, n_ts, 2]. If the shape of RDMs is [n_subs, n_channels, n_ts, n_conditions, n_conditions] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_subs, n_channels, n_ts, n_ts, 2]. If the shape of RDMs is [n_ts, n_conditions, n_conditions] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_ts, n_ts]. If the shape of RDMs is [n_subs, n_ts, n_conditions, n_conditions] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_subs, n_ts, n_ts]. If the shape of RDMs is [n_channels, n_ts, n_conditions, n_conditions] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_channels, n_ts, n_ts]. If the shape of RDMs is [n_subs, n_channels, n_ts, n_conditions, n_conditions] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_subs, n_channels, n_ts, n_ts]. Notes ----- Users can calculate RDMs by NeuroRA (zitonglu1996.github.io/neurora/) """ n = len(np.shape(RDMs)) if n == 3: n_ts, n_cons = np.shape(RDMs)[:2] CTSimilarities = np.zeros([n_ts, n_ts, 2], dtype=np.float) for t1 in range(n_ts): for t2 in range(n_ts): if method == 'spearman': CTSimilarities[t1, t2] = rdm_correlation_spearman( RDMs[t1], RDMs[t2], fisherz=fisherz) if method == 'pearson': CTSimilarities[t1, t2] = rdm_correlation_pearson( RDMs[t1], RDMs[t2], fisherz=fisherz) if method == 'kendall': CTSimilarities[t1, t2] = rdm_correlation_kendall( RDMs[t1], RDMs[t2], fisherz=fisherz) if method == 'similarity': CTSimilarities[t1, t2, 0] = rdm_similarity(RDMs[t1], RDMs[t2]) if method == 'distance': CTSimilarities[t1, t2, 0] = rdm_distance(RDMs[t1], RDMs[t2]) if method == 'spearman' or method == 'pearson' or method == 'kendall': return CTSimilarities if method == 'similarity' or method == 'distance': return CTSimilarities[:, :, 0] if n == 4: n1, n_ts, n_cons = np.shape(RDMs)[:3] CTSimilarities = np.zeros([n1, n_ts, n_ts, 2], dtype=np.float) for i in range(n1): for t1 in range(n_ts): for t2 in range(n_ts): if method == 'spearman': CTSimilarities[i, t1, t2] = rdm_correlation_spearman( RDMs[i, t1], RDMs[i, t2], fisherz=fisherz) if method == 'pearson': CTSimilarities[i, t1, t2] = rdm_correlation_pearson( RDMs[i, t1], RDMs[i, t2], fisherz=fisherz) if method == 'kendall': CTSimilarities[i, t1, t2] = rdm_correlation_kendall( RDMs[i, t1], RDMs[i, t2], fisherz=fisherz) if method == 'similarity': CTSimilarities[i, t1, t2, 0] = rdm_similarity( RDMs[i, t1], RDMs[i, t2]) if method == 'distance': CTSimilarities[i, t1, t2, 0] = rdm_distance( RDMs[i, t1], RDMs[i, t2]) if method == 'spearman' or method == 'pearson' or method == 'kendall': return CTSimilarities if method == 'similarity' or method == 'distance': return CTSimilarities[:, :, :, 0] if n == 5: n1, n2, n_ts, n_cons = np.shape(RDMs)[:4] CTSimilarities = np.zeros([n1, n2, n_ts, n_ts, 2], dtype=np.float) for i in range(n1): for j in range(n2): for t1 in range(n_ts): for t2 in range(n_ts): if method == 'spearman': CTSimilarities[i, j, t1, t2] = rdm_correlation_spearman( RDMs[i, j, t1], RDMs[i, j, t2], fisherz=fisherz) if method == 'pearson': CTSimilarities[i, j, t1, t2] = rdm_correlation_pearson( RDMs[i, j, t1], RDMs[i, j, t2], fisherz=fisherz) if method == 'kendall': CTSimilarities[i, j, t1, t2] = rdm_correlation_kendall( RDMs[i, j, t1], RDMs[i, j, t2], fisherz=fisherz) if method == 'similarity': CTSimilarities[i, j, t1, t2, 0] = rdm_similarity( RDMs[i, j, t1], RDMs[i, j, t2]) if method == 'distance': CTSimilarities[i, j, t1, t2, 0] = rdm_distance( RDMs[i, j, t1], RDMs[i, j, t2]) if method == 'spearman' or method == 'pearson' or method == 'kendall': return CTSimilarities if method == 'similarity' or method == 'distance': return CTSimilarities[:, :, :, :, 0]
def fmrirdms_corr(demo_rdm, fmri_rdms, method="spearman", rescale=False, permutation=False, iter=1000): """ Calculate the similarity between fMRI searchlight RDMs and a demo RDM Parameters ---------- demo_rdm : array [n_cons, n_cons] A demo RDM. fmri_rdms : array The fMRI-Searchlight RDMs. The shape of RDMs is [n_x, n_y, n_z, n_cons, n_cons]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. permutation : bool True or False. Default is False. Use permutation test or not. iter : int. Default is 1000. The times for iteration. Returns ------- corrs : array The similarities between fMRI searchlight RDMs and a demo RDM The shape of RDMs is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. Notes ----- The demo RDM could be a behavioral RDM, a hypothesis-based coding model RDM or a computational model RDM. """ if len(np.shape(demo_rdm)) != 2 or np.shape(demo_rdm)[0] != np.shape(demo_rdm)[1]: print("\nThe shape of the demo RDM should be [n_cons, n_cons].\n") return "Invalid input!" if len(np.shape(fmri_rdms)) != 5 or np.shape(fmri_rdms)[3] != np.shape(fmri_rdms)[4]: print("\nThe shape of the fMRI RDMs should be [n_x, n_y, n_z, n_cons, n_cons].\n") return "Invalid input!" # calculate the number of the calculation units in the x, y, z directions n_x = np.shape(fmri_rdms)[0] n_y = np.shape(fmri_rdms)[1] n_z = np.shape(fmri_rdms)[2] print("\nComputing similarities") # initialize the corrs corrs = np.full([n_x, n_y, n_z, 2], np.nan) total = n_x * n_y * n_z # calculate the corrs for i in range(n_x): for j in range(n_y): for k in range(n_z): # show the progressbar percent = (i * n_y * n_z + j * n_z + k + 1) / total * 100 show_progressbar("Calculating", percent) if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(demo_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(demo_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(demo_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) print("\nComputing finished!") return corrs
def rdms_corr(demo_rdm, eeg_rdms, method="spearman", rescale=False, permutation=False, iter=1000): """ Calculate the similarity between RDMs based on RDMs of EEG-like data and a demo RDM Parameters ---------- demo_rdm : array [n_cons, n_cons] A demo RDM. eeg_rdms : array The EEG/MEG/fNIRS/ECoG/sEEG/electrophysiological RDM(s). The shape can be [n_cons, n_cons] or [n1, n_cons, n_cons] or [n1, n2, n_cons, n_cons] or [n1, n2, n3, n_cons, n_cons]. ni(i=1, 2, 3) can be int(n_ts/timw_win), n_chls, n_subs. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. permutation : bool True or False. Default is False. Use permutation test or not. iter : int. Default is 1000. The times for iteration. Returns ------- corrs : array The similarities between EEG/MEG/fNIRS/ECoG/sEEG/electrophysiological RDMs and a demo RDM If the shape of eeg_rdms is [n_cons, n_cons], the shape of corrs will be [2]. If the shape of eeg_rdms is [n1, n_cons, n_cons], the shape of corrs will be [n1, 2]. If the shape of eeg_rdms is [n1, n2, n_cons, n_cons], the shape of corrs will be [n1, n2, 2]. If the shape of eeg_rdms is [n1, n2, n3, n_cons, n_cons], the shape of corrs will be [n1, n2, n3, 2]. ni(i=1, 2, 3) can be int(n_ts/timw_win), n_chls, n_subs. 2 represents a r-value and a p-value. Notes ----- The demo RDM could be a behavioral RDM, a hypothesis-based coding model RDM or a computational model RDM. """ if len(np.shape(demo_rdm)) != 2 or np.shape(demo_rdm)[0] != np.shape(demo_rdm)[1]: print("\nThe shape of the demo RDM should be [n_cons, n_cons].\n") return "Invalid input!" if len(np.shape(eeg_rdms)) < 2 or len(np.shape(eeg_rdms)) > 5 or np.shape(eeg_rdms)[-1] != np.shape(eeg_rdms)[-2]: print("\nThe shape of the EEG-like RDMs should be [n_cons, n_cons] or [n1, n_cons, n_cons] or " "[n1, n2, n_cons, n_cons] or [n1, n2, n3, n_cons, n_cons].\n") return "Invalid input!" if len(eeg_rdms.shape) == 5: print("\nComputing similarities") n1, n2, n3 = eeg_rdms.shape[:3] # initialize the corrs corrs = np.zeros([n1, n2, n3, 2], dtype=np.float64) total = n1 * n2 * n3 # calculate the corrs for i in range(n1): for j in range(n2): for k in range(n3): # show the progressbar percent = (i * n2 * n2 + j * n3 + k + 1) / total * 100 show_progressbar("Calculating", percent) if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(demo_rdm, eeg_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(demo_rdm, eeg_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(demo_rdm, eeg_rdms[i, j, k], rescale=rescale) print("\nComputing finished!") return corrs if len(eeg_rdms.shape) == 4: print("\nComputing similarities") n1, n2 = eeg_rdms.shape[:2] # initialize the corrs corrs = np.zeros([n1, n2, 2], dtype=np.float64) total = n1 * n2 # calculate the corrs for i in range(n1): for j in range(n2): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(demo_rdm, eeg_rdms[i, j], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i, j], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i, j], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(demo_rdm, eeg_rdms[i, j], rescale=rescale) print("\nComputing finished!") return corrs if len(eeg_rdms.shape) == 3: print("\nComputing similarities") n1 = eeg_rdms.shape[0] # initialize the corrs corrs = np.zeros([n1, 2], dtype=np.float64) # calculate the corrs for i in range(n1): if method == "spearman": corrs[i] = rdm_correlation_spearman(demo_rdm, eeg_rdms[i], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, 0] = rdm_similarity(demo_rdm, eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(demo_rdm, eeg_rdms[i], rescale=rescale) print("\nComputing finished!") return corrs print("\nComputing the similarity") # initialize the corrs corr = np.zeros([2], dtype=np.float64) # calculate the corrs if method == "spearman": corr = rdm_correlation_spearman(demo_rdm, eeg_rdms, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corr = rdm_correlation_pearson(demo_rdm, eeg_rdms, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corr = rdm_correlation_kendall(demo_rdm, eeg_rdms, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corr[0] = rdm_similarity(demo_rdm, eeg_rdms, rescale=rescale) elif method == "distance": corr[0] = rdm_distance(demo_rdm, eeg_rdms, rescale=rescale) print("\nComputing finished!") return corr
def ctsim_drsa_cal(Model_RDMs, RDMs, method='spearman'): """ Calculate the Cross-Temporal Similarities between temporal model RDMs and temporal neural RDMs (dynamic-RSA) Parameters ---------- Model_RDMs : array The Coding Model RDMs. The shape should be [n_ts, n_cons, n_cons]. n_ts and n_cons represent the number of time-points and the number of conditions, respectively. RDMs : array The Representational Dissimilarity Matrices in time series. The shape could be [n_ts, n_cons, n_cons] or [n_subs, n_ts, n_cons, n_cons] or [n_channels, n_ts, n_cons, n_cons] or [n_subs, n_channels, n_ts, n_cons, n_cons]. n_ts, n_cons, n_subs, n_channels represent the number of time-points, the number of conditions, the number of subjects and the number of channels, respectively. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. Returns ------- CTSimilarities : array Cross-temporal similarities. If the shape of RDMs is [n_ts, n_cons, n_cons] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_ts, n_ts, 2]. If the shape of RDMs is [n_subs, n_ts, n_cons, n_cons] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_subs, n_ts, n_ts, 2]. If the shape of RDMs is [n_chls, n_ts, n_cons, n_cons] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_chls, n_ts, n_ts, 2]. If the shape of RDMs is [n_subs, n_chls, n_ts, n_cons, n_cons] and method='spearman' or 'pearson' or 'kendall', the shape of CTSimilarities will be [n_subs, n_chls, n_ts, n_ts, 2]. If the shape of RDMs is [n_ts, n_cons, n_cons] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_ts, n_ts]. If the shape of RDMs is [n_subs, n_ts, n_cons, n_cons] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_subs, n_ts, n_ts]. If the shape of RDMs is [n_chls, n_ts, n_cons, n_cons] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_chls, n_ts, n_ts]. If the shape of RDMs is [n_subs, n_chls, n_ts, n_cons, n_cons] and method='similarity' or 'distance', the shape of CTSimilarities will be [n_subs, n_chls, n_ts, n_ts]. """ n = len(np.shape(RDMs)) if n == 3: n_ts, n_cons = np.shape(RDMs)[:2] CTSimilarities = np.zeros([n_ts, n_ts, 2], dtype=np.float) for t1 in range(n_ts): for t2 in range(n_ts): if method == 'spearman': CTSimilarities[t1, t2] = rdm_correlation_spearman( RDMs[t1], Model_RDMs[t2]) if method == 'pearson': CTSimilarities[t1, t2] = rdm_correlation_pearson( RDMs[t1], Model_RDMs[t2]) if method == 'kendall': CTSimilarities[t1, t2] = rdm_correlation_kendall( RDMs[t1], Model_RDMs[t2]) if method == 'similarity': CTSimilarities[t1, t2, 0] = rdm_similarity(RDMs[t1], Model_RDMs[t2]) if method == 'distance': CTSimilarities[t1, t2, 0] = rdm_distance(RDMs[t1], Model_RDMs[t2]) if method == 'spearman' or method == 'pearson' or method == 'kendall': return CTSimilarities if method == 'similarity' or method == 'distance': return CTSimilarities[:, :, 0] if n == 4: n1, n_ts, n_cons = np.shape(RDMs)[:3] CTSimilarities = np.zeros([n1, n_ts, n_ts, 2], dtype=np.float) for i in range(n1): for t1 in range(n_ts): for t2 in range(n_ts): if method == 'spearman': CTSimilarities[i, t1, t2] = rdm_correlation_spearman( RDMs[i, t1], Model_RDMs[i, t2]) if method == 'pearson': CTSimilarities[i, t1, t2] = rdm_correlation_pearson( RDMs[i, t1], Model_RDMs[i, t2]) if method == 'kendall': CTSimilarities[i, t1, t2] = rdm_correlation_kendall( RDMs[i, t1], Model_RDMs[i, t2]) if method == 'similarity': CTSimilarities[i, t1, t2, 0] = rdm_similarity( RDMs[i, t1], Model_RDMs[i, t2]) if method == 'distance': CTSimilarities[i, t1, t2, 0] = rdm_distance( RDMs[i, t1], Model_RDMs[i, t2]) if method == 'spearman' or method == 'pearson' or method == 'kendall': return CTSimilarities if method == 'similarity' or method == 'distance': return CTSimilarities[:, :, :, 0] if n == 5: n1, n2, n_ts, n_cons = np.shape(RDMs)[:4] CTSimilarities = np.zeros([n1, n2, n_ts, n_ts, 2], dtype=np.float) for i in range(n1): for j in range(n2): for t1 in range(n_ts): for t2 in range(n_ts): if method == 'spearman': CTSimilarities[i, j, t1, t2] = rdm_correlation_spearman( RDMs[i, j, t1], Model_RDMs[i, j, t2]) if method == 'pearson': CTSimilarities[i, j, t1, t2] = rdm_correlation_pearson( RDMs[i, j, t1], Model_RDMs[i, j, t2]) if method == 'kendall': CTSimilarities[i, j, t1, t2] = rdm_correlation_kendall( RDMs[i, j, t1], Model_RDMs[i, j, t2]) if method == 'similarity': CTSimilarities[i, j, t1, t2, 0] = rdm_similarity( RDMs[i, j, t1], Model_RDMs[i, j, t2]) if method == 'distance': CTSimilarities[i, j, t1, t2, 0] = rdm_distance( RDMs[i, j, t1], Model_RDMs[i, j, t2]) if method == 'spearman' or method == 'pearson' or method == 'kendall': return CTSimilarities if method == 'similarity' or method == 'distance': return CTSimilarities[:, :, :, :, 0]
def eegANDfmri_corr(eeg_data, fmri_data, chl_opt=0, ksize=[3, 3, 3], strides=[1, 1, 1], sub_result=1, method="spearman", fisherz=False, rescale=False, permutation=False, iter=5000): """ Calculate the Similarities between EEG/MEG/fNIRS data and fMRI data for searchligt Parameters ---------- eeg_data : array The EEG/MEG/fNIRS data. The shape of EEGdata must be [n_cons, n_subs, n_trials, n_chls, n_ts]. n_cons, n_subs, n_trials, n_chls & n_ts represent the number of conidtions, the number of subjects, the number of trials, the number of channels & the number of time-points, respectively. fmri_data : array The fmri data. The shape of fmri_data must be [n_cons, n_subs, nx, ny, nz]. n_cons, nx, ny, nz represent the number of conditions, the number of subs & the size of fMRI-img, respectively. chl_opt : int 0 or 1. Default is 0. Calculate the RDM & similarities for each channel or not. If chl_opt=0, calculating based on all channels' data. If chl_opt=1, calculating based on each channel's data respectively. ksize : array or list [kx, ky, kz]. Default is [3, 3, 3]. The size of the calculation unit for searchlight. kx, ky, kz represent the number of voxels along the x, y, z axis. strides : array or list [sx, sy, sz]. Default is [1, 1, 1]. The strides for calculating along the x, y, z axis. sub_result: int 0 or 1. Default is 1. Return the subject-result or average-result. If sub_result=0, return the average result. If sub_result=1, return the results of each subject. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. fisherz : bool True or False. Default is False. Do the Fisher-Z transform of the RDMs or not. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. permutation : bool True or False. Default is False. Use permutation test or not. iter : int. Default is 5000. The times for iteration. Returns ------- corrs : array The similarities between EEG/MEG/fNIRS data and fMRI data for searchlight. If chl_opt=1 & sub_result=1, the shape of corrs is [n_subs, n_chls, n_x, n_y, n_z, 2]. n_subs, n_x, n_y, n_z represent the number of subjects, the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. If chl_opt=1 & sub_result=0, the shape of corrs is [n_chls, n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. If chl_opt=0 & sub_result=1, the shape of RDMs is [n_subs, n_x, n_y, n_z, 2]. n_subs, n_x, n_y, n_z represent the number of subjects, the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. If chl_opt=0 & sub_result=0, the shape of corrs is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. """ if len(np.shape(eeg_data)) != 5 or len(np.shape(fmri_data)) != 5: return "Invalid input!" # get the number of subjects subs = np.shape(fmri_data)[1] # get the size of the fMRI-img nx = np.shape(fmri_data)[2] ny = np.shape(fmri_data)[3] nz = np.shape(fmri_data)[4] # the size of the calculation units for searchlight kx = ksize[0] ky = ksize[1] kz = ksize[2] # strides for calculating along the x, y, z axis sx = strides[0] sy = strides[1] sz = strides[0] # calculate the number of the calculation units in the x, y, z directions n_x = int((nx - kx) / sx) + 1 n_y = int((ny - ky) / sy) + 1 n_z = int((nz - kz) / sz) + 1 # get the number of channels chls = np.shape(eeg_data)[3] # calculate the fmri_rdms for searchlight fmri_rdms = fmriRDM(fmri_data, sub_result=sub_result, ksize=ksize, strides=strides) print(fmri_rdms.shape) # calculate the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=sub_result, chl_opt=chl_opt) # chl_opt=1 if chl_opt == 1: # sub_result=1 if sub_result == 1: # chl_opt=1 & sub_result=1 # initialize the corrs corrs = np.full([subs, chls, n_x, n_y, n_z, 2], np.nan) # calculate the corrs for sub in range(subs): for j in range(n_x): for k in range(n_y): for l in range(n_z): for i in range(chls): if method == "spearman": corrs[sub, i, j, k, l] = rdm_correlation_spearman(eeg_rdms[sub, i], fmri_rdms[sub, j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[sub, i, j, k, l] = rdm_correlation_pearson(eeg_rdms[sub, i], fmri_rdms[sub, j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[sub, i, j, k, l] = rdm_correlation_kendall(eeg_rdms[sub, i], fmri_rdms[sub, j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[sub, i, j, k, l, 0] = rdm_similarity(eeg_rdms[sub, i], fmri_rdms[sub, j, k, l], rescale=rescale) elif method == "distance": corrs[sub, i, j, k, l, 0] = rdm_distance(eeg_rdms[sub, i], fmri_rdms[sub, i, j, k], rescale=rescale) return np.abs(corrs) # sub_result=0 # chl_opt=1 & sub_result=0 # initialize the corrs corrs = np.full([chls, n_x, n_y, n_z, 2], np.nan) # calculate the corrs for j in range(n_x): for k in range(n_y): for l in range(n_z): for i in range(chls): if method == "spearman": corrs[i, j, k, l] = rdm_correlation_spearman(eeg_rdms[i], fmri_rdms[j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k, l] = rdm_correlation_pearson(eeg_rdms[i], fmri_rdms[j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k, l] = rdm_correlation_kendall(eeg_rdms[i], fmri_rdms[j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, l, 0] = rdm_similarity(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "distance": corrs[i, j, k, l, 0] = rdm_distance(eeg_rdms[i], fmri_rdms[i, j, k], rescale=rescale) return np.abs(corrs) # chl_opt=0 # sub_result=1 if sub_result == 1: # chl_opt=0 & sub_result=1 # initialize the corrs corrs = np.full([subs, n_x, n_y, n_z, 2], np.nan) # calculate the corrs for i in range(subs): for j in range(n_x): for k in range(n_y): for l in range(n_z): if method == "spearman": corrs[i, j, k, l] = rdm_correlation_spearman(eeg_rdms[i], fmri_rdms[j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k, l] = rdm_correlation_pearson(eeg_rdms[i], fmri_rdms[j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k, l] = rdm_correlation_kendall(eeg_rdms[i], fmri_rdms[j, k, l], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, l, 0] = rdm_similarity(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "distance": corrs[i, j, k, l, 0] = rdm_distance(eeg_rdms[i], fmri_rdms[i, j, k], rescale=rescale) return corrs # sub_result=0 # chl_opt=0 & sub_result=0 # initialize the corrs corrs = np.full([n_x, n_y, n_z, 2], np.nan) # calculate the corrs for i in range(n_x): for j in range(n_y): for k in range(n_z): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(eeg_rdms, fmri_rdms[i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(eeg_rdms, fmri_rdms[i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(eeg_rdms, fmri_rdms[i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(eeg_rdms, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(eeg_rdms, fmri_rdms[i, j, k], rescale=rescale) return np.abs(corrs)
def bhvANDeeg_corr(bhv_data, eeg_data, sub_opt=1, chl_opt=0, time_opt=0, time_win=5, time_step=5, method="spearman", fisherz=False, rescale=False, permutation=False, iter=5000): """ Calculate the Similarities between behavioral data and EEG/MEG/fNIRS data Parameters ---------- bhv_data : array The behavioral data. The shape of bhv_data must be [n_cons, n_subs, n_trials]. n_cons, n_subs & n_trials represent the number of conidtions, the number of subjects & the number of trials, respectively. eeg_data : array The EEG/MEG/fNIRS data. The shape of EEGdata must be [n_cons, n_subs, n_trials, n_chls, n_ts]. n_cons, n_subs, n_trials, n_chls & n_ts represent the number of conidtions, the number of subjects, the number of trials, the number of channels & the number of time-points, respectively. sub_opt : int 0 or 1. Default is 0. Calculate the RDM & similarities for each subject or not. If sub_opt=0, calculating based on all data. If sub_opt=1, calculating based on each subject's data, respectively. chl_opt : int 0 or 1. Default is 0. Calculate the RDM & similarities for each channel or not. If chl_opt=0, calculating based on all channels' data. If chl_opt=1, calculating based on each channel's data respectively. time_opt : int 0 or 1. Default is 0. Calculate the RDM & similarities for each time-point or not If time_opt=0, calculating based on whole time-points' data. If time_opt=1, calculating based on each time-points respectively. time_win : int. Default is 5. Set a time-window for calculating the RDM & similarities for different time-points. Only when time_opt=1, time_win works. If time_win=5, that means each calculation process based on 5 time-points. time_step : int. Default is 5. The time step size for each time of calculating. Only when time_opt=1, time_step works. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. fisherz : bool True or False. Default is False. Do the Fisher-Z transform of the RDMs or not. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. permutation : bool True or False. Default is False. Use permutation test or not. iter : int. Default is 5000. The times for iteration. Returns ------- corrs : array The similarities between behavioral data and EEG/MEG/fNIRS data. If sub_opt=0 & chl_opt=0 & time_opt=0, return one corr result. The shape of corrs is [2], a r-value and a p-value. If method='similarity' or method='distance', the p-value is 0. If sub_opt=0 & chl_opt=0 & time_opt=1, return int((n_ts-time_win)/time_step)+1 corrs result. The shape of corrs is [int((n_ts-time_win)/time_step)+1, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If sub_opt=0 & chl_opt=1 & time_opt=0, return n_chls corrs result. The shape of corrs is [n_chls, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If sub_opt=0 & chl_opt=1 & time_opt=1, return n_chls*(int((n_ts-time_win)/time_step)+1) corrs result. The shape of corrs is [n_chls, int((n_ts-time_win)/time_step)+1, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If sub_opt=1 & chl_opt=0 & time_opt=0, return n_subs corr result. The shape of corrs is [n_subs, 2], a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If sub_opt=1 & chl_opt=0 & time_opt=1, return n_subs*(int((n_ts-time_win)/time_step)+1) corrs result. The shape of corrs is [n_subs, int((n_ts-time_win)/time_step)+1, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If sub_opt=1 & chl_opt=1 & time_opt=0, return n_subs*n_chls corrs result. The shape of corrs is [n_subs, n_chls, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If sub_opt=1 & chl_opt=1 & time_opt=1, return n_subs*n_chls*(int((n_ts-time_win)/time_step)+1) corrs result. The shape of corrs is [n_subs, n_chls, int((n_ts-time_win)/time_step)+1, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. """ if len(np.shape(bhv_data)) != 3 or len(np.shape(eeg_data)) != 5: return "Invalid input!" # get the number of subjects subs = np.shape(bhv_data)[1] # get the number of channels chls = np.shape(eeg_data)[3] # get the number of time-points for calculating ts = np.shape(eeg_data)[4] ts = int((ts-time_win)/time_step)+1 if sub_opt == 1: # calculate the bhv_rdm bhv_rdms = bhvRDM(bhv_data, sub_opt=sub_opt) if chl_opt == 0: if time_opt == 0: # sub_opt=1 & chl_opt=0 & time_opt=0 # calculate the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) # initialize the corrs corrs = np.zeros([subs, 2], dtype=np.float64) # calculate the corrs for i in range(subs): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdms[i], eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdms[i], eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdms[i], eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdms[i], eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdms[i], eeg_rdms[i], rescale=rescale) return corrs # sub_opt=1 & chl_opt=0 & time_opt=1 # calculate the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt, time_win=time_win, time_step=time_step) # initialize the corrs corrs = np.zeros([subs, ts, 2], dtype=np.float64) # calculate the corrs for i in range(subs): for j in range(ts): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(bhv_rdms[i], eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(bhv_rdms[i], eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(bhv_rdms[i], eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) return corrs if time_opt == 1: # sub_opt=1 & chl_opt=1 & time_opt=1 # calculate the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt, time_win=time_win, time_step=time_step) # initialize the corrs corrs = np.zeros([subs, chls, ts, 2], dtype=np.float64) # calculate the corrs for i in range(subs): for j in range(chls): for k in range(ts): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(bhv_rdms[i], eeg_rdms[i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(bhv_rdms[i], eeg_rdms[i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(bhv_rdms[i], eeg_rdms[i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(bhv_rdms[i], eeg_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(bhv_rdms[i], eeg_rdms[i, j, k], rescale=rescale) return corrs # sub_opt=1 & chl_opt=1 & time_opt=0 eeg_rdms = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) corrs = np.zeros([subs, chls, 2], dtype=np.float64) for i in range(subs): for j in range(chls): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(bhv_rdms[i], eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(bhv_rdms[i], eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(bhv_rdms[i], eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) return corrs # if sub_opt=0 bhv_rdm = bhvRDM(bhv_data, sub_opt=sub_opt) if chl_opt == 1: if time_opt == 1: # sub_opt = 0 & chl_opt = 1 & time_opt = 1 # calculate the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt, time_win=time_win, time_step=time_step) # initialize the corrs corrs = np.zeros([chls, ts, 2], dtype=np.float64) # calculate the corrs for i in range(chls): for j in range(ts): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(bhv_rdm, eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(bhv_rdm, eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(bhv_rdm, eeg_rdms[i, j], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(bhv_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(bhv_rdm, eeg_rdms[i, j], rescale=rescale) return corrs # sub_opt=0 & chl_opt=1 & time_opt=0 # calculate the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) # initialize the corrs corrs = np.zeros([chls, 2], dtype=np.float64) # calculate the corrs for i in range(chls): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, eeg_rdms[i], rescale=rescale) return corrs # if chl_opt=0 if time_opt == 1: # sub_opt=0 & chl_opt=0 & time_opt=1 # calculate the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt, time_win=time_win, time_step=time_step) # initialize the corrs corrs = np.zeros([ts, 2], dtype=np.float64) # calculate the corrs for i in range(ts): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, eeg_rdms[i], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, eeg_rdms[i], rescale=rescale) return corrs # sub_opt=0 & chl_opt=0 & time_opt=0 # calculate the eeg_rdms eeg_rdm = eegRDM(eeg_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) # initialize the corrs corr = np.zeros([2], dtype=np.float64) # calculate the corrs if method == "spearson": corr = rdm_correlation_spearman(bhv_rdm, eeg_rdm, fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corr = rdm_correlation_pearson(bhv_rdm, eeg_rdm, fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corr = rdm_correlation_kendall(bhv_rdm, eeg_rdm, fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corr[0] = rdm_similarity(bhv_rdm, eeg_rdm, rescale=rescale) elif method == "distance": corr[0] = rdm_distance(bhv_rdm, eeg_rdm, rescale=rescale) return corr
def bhvANDecog_corr(bhv_data, ele_data, time_win=5, time_step=5, ecog_opt="allin", method="spearman", rescale=False): """ Calculate the Similarities between behavioral data and sEEG/ECoG/eletricophysiological data Parameters ---------- bhv_data : array The behavioral data. The shape of bhv_data must be [n_cons, n_trials]. n_cons, n_subs & n_trials represent the number of conidtions, the number of subjects & the number of trials, respectively. ele_data : array The ECoG/sEEG/electrophysiology data. The shape of EEGdata must be [n_cons, n_trials, n_chls, n_ts]. n_cons, n_trials, n_chls & n_ts represent the number of conidtions, the number of trials, the number of channels & the number of time-points, respectively. time_win : int. Default is 5. Set a time-window for calculating the RDM & similarities for different time-points. Only when time_opt=1, time_win works. If time_win=5, that means each calculation process based on 5 time-points. time_step : int. Default is 5. The time step size for each time of calculating. Only when time_opt=1, time_step works. ecog_opt : string 'channel', 'time' or 'all'. Default is 'all'. Calculate the RDM for each channel or for each time-point or for the whole data. If ecog_opt='channel', return n_chls RDMs based on each channel's data. If ecog_opt='time', return int((n_ts-time_win)/time_step)+1 RDMs based on each time-point's data respectively. If ecog_opt='allin', return only one RDM based on all data. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. Returns ------- corrs : array The similarities between behavioral data and ECoG/sEEG/electrophysiology. If opt='channel', return n_chls corrs result. The shape of corrs is [n_chls, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If opt='time', return int(n_ts/time_win) corrs result. The shape of corrs is [int((n_ts-time_win)/time_step)+1, 2]. 2 represents a r-value and a p-value. If method='similarity' or method='distance', the p-values are all 0. If opt='all', return one corr result. The shape of corrs is [2], a r-value and a p-value. If method='similarity' or method='distance', the p-value is 0. """ # sub_opt = 1, bhv_data here belongs to one subject, and its shape must be : [cons, trials] # get the number of conditions & the number of trials cons, trials = np.shape(bhv_data) # shape of bhv_data: [cons, trials] -> [cons, subs, trials] & subs=1 bhv_data = np.reshape(bhv_data, [cons, 1, trials]) # calculate bhv_rdm bhv_rdm = bhvRDM(bhv_data) # ecog_opt='channel' if ecog_opt == "channel": # calculate the ecog_rdms ecog_rdms = ecogRDM(ele_data, opt="channel") # get the number of channels chls_num = np.shape(ele_data)[2] # initialize the corrs corrs = np.zeros([chls_num, 2], dtype=np.float64) # get the corrs for i in range(chls_num): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, ecog_rdms[i], rescale=rescale) return corrs # ecog_opt='time' elif ecog_opt == "time": # calculate the ecog_rdms ecog_rdms = ecogRDM(ele_data, time_win=time_win, time_step=time_step, opt="time") # get the number of time-points for calculating ts = np.shape(ele_data)[3] ts = int((ts - time_win) / time_step) + 1 # initialize the corrs corrs = np.zeros([ts, 2], dtype=np.float64) # calculate the corrs for i in range(ts): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, ecog_rdms[i], rescale=rescale) return corrs # ecog_opt="allin" # calculate the ecog_rdm ecog_rdm = ecogRDM(ele_data, opt="allin") # initialize the corr corr = np.zeros([2], dtype=np.float64) # calculate the corr if method == "spearman": corr = rdm_correlation_spearman(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "pearson": corr = rdm_correlation_pearson(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "kendall": corr = rdm_correlation_kendall(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "similarity": corr[0] = rdm_similarity(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "distance": corr[0] = rdm_distance(bhv_rdm, ecog_rdm, rescale=rescale) return corr
def eegANDfmri_corr(eeg_data, fmri_data, chl_opt=0, ksize=[3, 3, 3], strides=[1, 1, 1], method="spearman", rescale=False): # sub_opt=0, time_opt=0 nx = np.shape(fmri_data)[2] ny = np.shape(fmri_data)[3] nz = np.shape(fmri_data)[4] cons = np.shape(eeg_data)[0] kx = ksize[0] ky = ksize[1] kz = ksize[2] sx = strides[0] sy = strides[1] sz = strides[0] n_x = int((nx - kx) / sx) + 1 n_y = int((ny - ky) / sy) + 1 n_z = int((nz - kz) / sz) + 1 fmri_rdms = fmriRDM(fmri_data, ksize=ksize, strides=strides) if chl_opt == 1: chls = np.shape(eeg_data)[3] eeg_rdms = eegRDM(eeg_data, sub_opt=0, chl_opt=1, time_opt=0) corrs = np.full([chls, n_x, n_y, n_z, 2], np.nan) for j in range(n_x): for k in range(n_y): for l in range(n_z): """index = 0 for m in range(cons): for n in range(cons): if math.isnan(fmri_rdms[j, k, l]) == True: index = index + 1""" for i in range(chls): """if index != 0: corrs[i, j, k, l, 0] = 0 corrs[i, j, k, l, 1] = 1""" if method == "spearman": corrs[i, j, k, l] = rdm_correlation_spearman( eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "pearson": corrs[i, j, k, l] = rdm_correlation_pearson(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "kendall": corrs[i, j, k, l] = rdm_correlation_kendall(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "similarity": corrs[i, j, k, l, 0] = rdm_similarity(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "distance": corrs[i, j, k, l, 0] = rdm_distance(eeg_rdms[i], fmri_rdms[i, j, k], rescale=rescale) return np.abs(corrs) # if chl_opt=0 eeg_rdm = eegRDM(eeg_data, sub_opt=0, chl_opt=0, time_opt=0) corrs = np.full([n_x, n_y, n_z, 2], np.nan) for i in range(n_x): for j in range(n_y): for k in range(n_z): """index = 0 for m in range(cons): for n in range(cons): if math.isnan(fmri_rdms[i, j, k]) == True: index = index + 1 if index != 0: corrs[i, j, k, 0] = 0 corrs[i, j, k, 1] = 1""" if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) return np.abs(corrs)
def bhvANDfmri_corr(bhv_data, fmri_data, bhv_data_opt=1, ksize=[3, 3, 3], strides=[1, 1, 1], method="spearman", rescale=False): # sub_opt=1 if bhv_data_opt == 0: bhv_rdm = bhvRDM(bhv_data, sub_opt=0, data_opt=0) # if bhv_data_opt=1 else: bhv_rdm = bhvRDM(bhv_data, sub_opt=0, data_opt=1) print("****************") print("get behavior RDM") print(bhv_rdm) fmri_rdms = fmriRDM(fmri_data, ksize=ksize, strides=strides) print("****************") print("get fMRI RDM") print(np.shape(fmri_rdms)) cons = np.shape(bhv_data)[0] nx = np.shape(fmri_data)[2] ny = np.shape(fmri_data)[3] nz = np.shape(fmri_data)[4] kx = ksize[0] ky = ksize[1] kz = ksize[2] sx = strides[0] sy = strides[1] sz = strides[2] n_x = int((nx - kx) / sx) + 1 n_y = int((ny - ky) / sy) + 1 n_z = int((nz - kz) / sz) + 1 corrs = np.full([n_x, n_y, n_z, 2], np.nan) for i in range(n_x): for j in range(n_y): for k in range(n_z): """index = 0 for m in range(cons): for n in range(cons): if math.isnan(fmri_rdms[i, j, k, m, n]) == True: index = index + 1 if index != 0: corrs[i, j, k, 0] = 0 corrs[i, j, k, 1] = 1""" if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) print(corrs[i, j, k]) return corrs
def bhvANDecog_corr(bhv_data, ele_data, time_win=5, ecog_opt="allin", method="spearman", rescale=False): # sub_opt = 1, bhv_data here belongs to one subject, and its shape must be : [cons, trials] cons, trials = np.shape(bhv_data) ts = np.shape(ele_data)[3] bhv_data = np.reshape(bhv_data, [cons, 1, trials]) bhv_rdm = np.reshape(bhvRDM(bhv_data, sub_opt=1, data_opt=1), [cons, cons]) if ecog_opt == "channel": ecog_rdms = ecogRDM(ele_data, opt="channel") chls_num = np.shape(ele_data)[2] corrs = np.zeros([chls_num, 2], dtype=np.float64) for i in range(chls_num): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, ecog_rdms[i], rescale=rescale) return corrs elif ecog_opt == "time": ecog_rdms = ecogRDM(ele_data, time_win=5, opt="time") ts = int(np.shape(ele_data)[3] / time_win) corrs = np.zeros([ts, 2], dtype=np.float64) for i in range(ts): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, ecog_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, ecog_rdms[i], rescale=rescale) return corrs # if ecog_opt="allin" ecog_rdm = ecogRDM(ele_data, opt="allin") corr = np.zeros([2], dtype=np.float64) if method == "spearman": corr = rdm_correlation_spearman(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "pearson": corr = rdm_correlation_pearson(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "kendall": corr = rdm_correlation_kendall(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "similarity": corr[0] = rdm_similarity(bhv_rdm, ecog_rdm, rescale=rescale) elif method == "distance": corr[0] = rdm_distance(bhv_rdm, ecog_rdm, rescale=rescale) return corr
def bhvANDeeg_corr(bhv_data, EEG_data, sub_opt=0, bhv_data_opt=1, time_win=5, chl_opt=0, time_opt=0, method="spearman", rescale=False): subs = np.shape(bhv_data)[1] chls = np.shape(EEG_data)[3] ts = int(np.shape(EEG_data)[4] / time_win) if sub_opt == 1: if bhv_data_opt == 0: return None # if bhv_data_opt=1 bhv_rdms = bhvRDM(bhv_data, sub_opt=sub_opt, data_opt=bhv_data_opt) if chl_opt == 0: if time_opt == 0: eeg_rdms = eegRDM(EEG_data, time_win=time_win, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) corrs = np.zeros([subs, 2], dtype=np.float64) for i in range(subs): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdms[i], eeg_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdms[i], eeg_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdms[i], eeg_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdms[i], eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdms[i], eeg_rdms[i], rescale=rescale) return corrs # if time_opt=1 eeg_rdms = eegRDM(EEG_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) corrs = np.zeros([subs, ts, 2], dtype=np.float64) for i in range(subs): for j in range(ts): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) return corrs # chl_opt=1 if time_opt == 1: return None # time_opt=0 eeg_rdms = eegRDM(EEG_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) corrs = np.zeros([subs, chls], dtype=np.float64) for i in range(subs): for j in range(chls): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(bhv_rdms[i], eeg_rdms[i, j], rescale=rescale) return corrs # if sub_opt=0 bhv_rdm = bhvRDM(bhv_data, sub_opt=sub_opt, data_opt=bhv_data_opt) if chl_opt == 1: if time_opt == 1: eeg_rdms = eegRDM(EEG_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) corrs = np.zeros([chls, ts, 2], dtype=np.float64) for i in range(chls): for j in range(ts): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(bhv_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(bhv_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(bhv_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(bhv_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(bhv_rdm, eeg_rdms[i, j], rescale=rescale) return corrs # if time_opt=0 eeg_rdms = eegRDM(EEG_data, sub_opt=sub_opt, chl_opt=chl_opt, time_opt=time_opt) corrs = np.zeros([chls, 2], dtype=np.float64) for i in range(chls): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, eeg_rdms[i]) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, eeg_rdms[i]) return corrs # if chl_opt=0 if time_opt == 1: eeg_rdms = eegRDM(EEG_data, sub_opt=0, chl_opt=0, time_opt=1) corrs = np.zeros([ts, 2], dtype=np.float64) for i in range(ts): if method == "spearman": corrs[i] = rdm_correlation_spearman(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(bhv_rdm, eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(bhv_rdm, eeg_rdms[i], rescale=rescale) return corrs # if time_opt=0 eeg_rdm = eegRDM(EEG_data, sub_opt=0, chl_opt=0, time_opt=0) corr = np.zeros([2], dtype=np.float64) if method == "spearson": corr = rdm_correlation_spearman(bhv_rdm, eeg_rdm, rescale=rescale) elif method == "pearson": corr = rdm_correlation_pearson(bhv_rdm, eeg_rdm, rescale=rescale) elif method == "kendall": corr = rdm_correlation_kendall(bhv_rdm, eeg_rdm, rescale=rescale) elif method == "similarity": corr[0] = rdm_similarity(bhv_rdm, eeg_rdm, rescale=rescale) elif method == "distance": corr[0] = rdm_distance(bhv_rdm, eeg_rdm, rescale=rescale) return corr
def rdms_corr(demo_rdm, eeg_rdms, method="spearman", rescale=False): """ Calculate the Similarities between EEG/MEG/fNIRS/ECoG/sEEG/electrophysiological RDMs and a demo RDM Parameters ---------- demo_rdm : array [n_cons, n_cons] A demo RDM. eeg_rdms : array The EEG/MEG/fNIRS/ECoG/sEEG/electrophysiological RDM(s). The shape can be [n_cons, n_cons] or [n1, n_cons, n_cons] or [n1, n2, n_cons, n_cons] or [n1, n2, n3, n_cons, n_cons]. ni(i=1, 2, 3) can be int(n_ts/timw_win), n_chls, n_subs. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. Returns ------- corrs : array The similarities between EEG/MEG/fNIRS/ECoG/sEEG/electrophysiological RDMs and a demo RDM If the shape of eeg_rdms is [n_cons, n_cons], the shape of corrs will be [2]. If the shape of eeg_rdms is [n1, n_cons, n_cons], the shape of corrs will be [n1, 2]. If the shape of eeg_rdms is [n1, n2, n_cons, n_cons], the shape of corrs will be [n1, n2, 2]. If the shape of eeg_rdms is [n1, n2, n3, n_cons, n_cons], the shape of corrs will be [n1, n2, n3, 2]. ni(i=1, 2, 3) can be int(n_ts/timw_win), n_chls, n_subs. 2 represents a r-value and a p-value. """ if len(eeg_rdms.shape) == 5: n1, n2, n3 = eeg_rdms.shape[:3] # initialize the corrs corrs = np.zeros([n1, n2, n3, 2], dtype=np.float64) # calculate the corrs for i in range(n1): for j in range(n2): for k in range(n3): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(demo_rdm, eeg_rdms[i, j], rescale=rescale) return corrs if len(eeg_rdms.shape) == 4: n1, n2 = eeg_rdms.shape[:2] # initialize the corrs corrs = np.zeros([n1, n2, 2], dtype=np.float64) # calculate the corrs for i in range(n1): for j in range(n2): if method == "spearman": corrs[i, j] = rdm_correlation_spearman(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "pearson": corrs[i, j] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "kendall": corrs[i, j] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "similarity": corrs[i, j, 0] = rdm_similarity(demo_rdm, eeg_rdms[i, j], rescale=rescale) elif method == "distance": corrs[i, j, 0] = rdm_distance(demo_rdm, eeg_rdms[i, j], rescale=rescale) return corrs if len(eeg_rdms.shape) == 3: n1 = eeg_rdms.shape[0] # initialize the corrs corrs = np.zeros([n1, 2], dtype=np.float64) # calculate the corrs for i in range(n1): if method == "spearman": corrs[i] = rdm_correlation_spearman(demo_rdm, eeg_rdms[i], rescale=rescale) elif method == "pearson": corrs[i] = rdm_correlation_pearson(demo_rdm, eeg_rdms[i], rescale=rescale) elif method == "kendall": corrs[i] = rdm_correlation_kendall(demo_rdm, eeg_rdms[i], rescale=rescale) elif method == "similarity": corrs[i, 0] = rdm_similarity(demo_rdm, eeg_rdms[i], rescale=rescale) elif method == "distance": corrs[i, 0] = rdm_distance(demo_rdm, eeg_rdms[i], rescale=rescale) return corrs # initialize the corrs corr = np.zeros([2], dtype=np.float64) # calculate the corrs if method == "spearman": corr = rdm_correlation_spearman(demo_rdm, eeg_rdms, rescale=rescale) elif method == "pearson": corr = rdm_correlation_pearson(demo_rdm, eeg_rdms, rescale=rescale) elif method == "kendall": corr = rdm_correlation_kendall(demo_rdm, eeg_rdms, rescale=rescale) elif method == "similarity": corr[0] = rdm_similarity(demo_rdm, eeg_rdms, rescale=rescale) elif method == "distance": corr[0] = rdm_distance(demo_rdm, eeg_rdms, rescale=rescale) return corr
def fmrirdms_corr(demo_rdm, fmri_rdms, method="spearman", rescale=False): """ Calculate the Similarities between fMRI searchlight RDMs and a demo RDM Parameters ---------- demo_rdm : array [n_cons, n_cons] A demo RDM. fmri_rdms : array The fMRI-Searchlight RDMs. The shape of RDMs is [n_x, n_y, n_z, n_cons, n_cons]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. Returns ------- corrs : array The similarities between fMRI searchlight RDMs and a demo RDM The shape of RDMs is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. """ # calculate the number of the calculation units in the x, y, z directions n_x = np.shape(fmri_rdms)[0] n_y = np.shape(fmri_rdms)[1] n_z = np.shape(fmri_rdms)[2] # initialize the corrs corrs = np.full([n_x, n_y, n_z, 2], np.nan) # calculate the corrs for i in range(n_x): for j in range(n_y): for k in range(n_z): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) print(corrs[i, j, k]) return np.abs(corrs)
def fmrirdms_corr(demo_rdm, fmri_rdms, method="spearman", rescale=False, permutation=False, iter=5000): """ Calculate the similarity between fMRI searchlight RDMs and a demo RDM Parameters ---------- demo_rdm : array [n_cons, n_cons] A demo RDM. fmri_rdms : array The fMRI-Searchlight RDMs. The shape of RDMs is [n_x, n_y, n_z, n_cons, n_cons]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. fisherz : bool True or False. Default is False. Do the Fisher-Z transform of the RDMs or not. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. permutation : bool True or False. Default is False. Use permutation test or not. iter : int. Default is 5000. The times for iteration. Returns ------- corrs : array The similarities between fMRI searchlight RDMs and a demo RDM The shape of RDMs is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. """ if len(np.shape(demo_rdm)) != 2 or len(np.shape(fmri_rdms)) != 5 or np.shape(demo_rdm)[0] != np.shape(demo_rdm)[1] \ or np.shape(fmri_rdms)[3] != np.shape(fmri_rdms)[4]: return "Invalid input!" # calculate the number of the calculation units in the x, y, z directions n_x = np.shape(fmri_rdms)[0] n_y = np.shape(fmri_rdms)[1] n_z = np.shape(fmri_rdms)[2] # initialize the corrs corrs = np.full([n_x, n_y, n_z, 2], np.nan) # calculate the corrs for i in range(n_x): for j in range(n_y): for k in range(n_z): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman( demo_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(demo_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(demo_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(demo_rdm, fmri_rdms[i, j, k], rescale=rescale) return corrs
# Plot the RDM of -100ms, 0ms, 100ms, 200ms, 30ms, 400ms times = [0, 10, 20, 30, 40, 50] for t in times: plot_rdm(rdms[t], percentile=True) # In[6] """********** Section 6: Calculating the Similarity between two RDMs **********""" # RDM of 200ms rdm_sample1 = rdms[30] # RDM of 800ms rdm_sample2 = rdms[90] # calculate the correlation coefficient between these two RDMs corr = rdm_correlation_spearman(rdm_sample1, rdm_sample2) print(corr) # In[7] """********** Section 7: Calculating the Similarity and Plotting **********""" # Calculate the representational similarity between 200ms and all the time points corrs1 = rdms_corr(rdm_sample1, rdms) # Plot the corrs1 corrs1 = np.reshape(corrs1, [1, 110, 2]) plot_corrs_by_time(corrs1, time_unit=[-0.1, 0.01]) # Calculate and Plot multi-corrs corrs2 = rdms_corr(rdm_sample2, rdms)
def bhvANDfmri_corr(bhv_data, fmri_data, ksize=[3, 3, 3], strides=[1, 1, 1], method="spearman", rescale=False): """ Calculate the Similarities between behavioral data and fMRI data for searchlight Parameters ---------- bhv_data : array The behavioral data. The shape of bhv_data must be [n_cons, n_subs, n_trials]. n_cons, n_subs & n_trials represent the number of conidtions, the number of subjects & the number of trials, respectively. fmri_data : array The fmri data. The shape of fmri_data must be [n_cons, n_subs, n_chls, nx, ny, nz]. n_cons, n_chls, nx, ny, nz represent the number of conidtions, the number of channels & the size of fMRI-img, respectively. ksize : array or list [kx, ky, kz]. Default is [3, 3, 3]. The size of the fMRI-img. nx, ny, nz represent the number of voxels along the x, y, z axis. strides : array or list [sx, sy, sz]. Default is [1, 1, 1]. The strides for calculating along the x, y, z axis. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. Returns ------- corrs : array The similarities between behavioral data and fMRI data for searchlight. The shape of RDMs is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. """ # calculate the bhv_rdm bhv_rdm = bhvRDM(bhv_data, sub_opt=0) print("****************") print("get behavior RDM") print(bhv_rdm) # calculate the fmri_rdms for searchlight fmri_rdms = fmriRDM(fmri_data, ksize=ksize, strides=strides) print("****************") print("get fMRI RDM") print(np.shape(fmri_rdms)) # get the size of the fMRI-img nx = np.shape(fmri_data)[2] ny = np.shape(fmri_data)[3] nz = np.shape(fmri_data)[4] # the size of the calculation units for searchlight kx = ksize[0] ky = ksize[1] kz = ksize[2] # strides for calculating along the x, y, z axis sx = strides[0] sy = strides[1] sz = strides[2] # calculate the number of the calculation units in the x, y, z directions n_x = int((nx - kx) / sx) + 1 n_y = int((ny - ky) / sy) + 1 n_z = int((nz - kz) / sz) + 1 # initialize the corrs corrs = np.full([n_x, n_y, n_z, 2], np.nan) # calculate the corrs for i in range(n_x): for j in range(n_y): for k in range(n_z): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) print(corrs[i, j, k]) return corrs
def bhvANDfmri_corr(bhv_data, fmri_data, ksize=[3, 3, 3], strides=[1, 1, 1], sub_result=1, method="spearman", fisherz=False, rescale=False, permutation=False, iter=5000): """ Calculate the Similarities between behavioral data and fMRI data for searchlight Parameters ---------- bhv_data : array The behavioral data. The shape of bhv_data must be [n_cons, n_subs, n_trials]. n_cons, n_subs & n_trials represent the number of conidtions, the number of subjects & the number of trials, respectively. fmri_data : array The fmri data. The shape of fmri_data must be [n_cons, n_subs, nx, ny, nz]. n_cons, nx, ny, nz represent the number of conditions, the number of subs & the size of fMRI-img, respectively. ksize : array or list [kx, ky, kz]. Default is [3, 3, 3]. The size of the calculation unit for searchlight. kx, ky, kz represent the number of voxels along the x, y, z axis. strides : array or list [sx, sy, sz]. Default is [1, 1, 1]. The strides for calculating along the x, y, z axis. sub_result: int 0 or 1. Default is 1. Return the subject-result or average-result. If sub_result=0, return the average result. If sub_result=1, return the results of each subject. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. fisherz : bool True or False. Default is False. Do the Fisher-Z transform of the RDMs or not. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. permutation : bool True or False. Default is False. Use permutation test or not. iter : int. Default is 5000. The times for iteration. Returns ------- corrs : array The similarities between behavioral data and fMRI data for searchlight. If sub_result=0, the shape of corrs is [n_x, n_y, n_z, 2]. If sub_result=1, the shape of corrs is [n_subs, n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. """ if len(np.shape(bhv_data)) != 3 or len(np.shape(fmri_data)) != 5: return "Invalid input!" # calculate the bhv_rdm bhv_rdm = bhvRDM(bhv_data, sub_opt=0) print("****************") print("get behavior RDM") print(bhv_rdm) # calculate the fmri_rdms for searchlight fmri_rdms = fmriRDM(fmri_data, ksize=ksize, strides=strides, sub_result=sub_result) print("****************") print("get fMRI RDM") print(np.shape(fmri_rdms)) # get the number of subjects subs = np.shape(fmri_data)[1] # get the size of the fMRI-img nx = np.shape(fmri_data)[2] ny = np.shape(fmri_data)[3] nz = np.shape(fmri_data)[4] # the size of the calculation units for searchlight kx = ksize[0] ky = ksize[1] kz = ksize[2] # strides for calculating along the x, y, z axis sx = strides[0] sy = strides[1] sz = strides[2] # calculate the number of the calculation units in the x, y, z directions n_x = int((nx - kx) / sx) + 1 n_y = int((ny - ky) / sy) + 1 n_z = int((nz - kz) / sz) + 1 # sub_result=0 if sub_result == 0: # initialize the corrs corrs = np.full([n_x, n_y, n_z, 2], np.nan) # calculate the corrs for i in range(n_x): for j in range(n_y): for k in range(n_z): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(bhv_rdm, fmri_rdms[i, j, k], rescale=rescale) print(corrs[i, j, k]) return corrs # sub_result=1 # initialize the corrs corrs = np.full([subs, n_x, n_y, n_z, 2], np.nan) # calculate the corrs for sub in range(subs): for i in range(n_x): for j in range(n_y): for k in range(n_z): if method == "spearman": corrs[sub, i, j, k] = rdm_correlation_spearman(bhv_rdm, fmri_rdms[sub, i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "pearson": corrs[sub, i, j, k] = rdm_correlation_pearson(bhv_rdm, fmri_rdms[sub, i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "kendall": corrs[sub, i, j, k] = rdm_correlation_kendall(bhv_rdm, fmri_rdms[sub, i, j, k], fisherz=fisherz, rescale=rescale, permutation=permutation, iter=iter) elif method == "similarity": corrs[sub, i, j, k, 0] = rdm_similarity(bhv_rdm, fmri_rdms[sub, i, j, k], rescale=rescale) elif method == "distance": corrs[sub, i, j, k, 0] = rdm_distance(bhv_rdm, fmri_rdms[sub, i, j, k], rescale=rescale) print(corrs[sub, i, j, k]) return corrs
def eegANDfmri_corr(eeg_data, fmri_data, chl_opt=0, ksize=[3, 3, 3], strides=[1, 1, 1], method="spearman", rescale=False): """ Calculate the Similarities between EEG/MEG/fNIRS data and fMRI data for searchligt Parameters ---------- eeg_data : array The EEG/MEG/fNIRS data. The shape of EEGdata must be [n_cons, n_subs, n_trials, n_chls, n_ts]. n_cons, n_subs, n_trials, n_chls & n_ts represent the number of conidtions, the number of subjects, the number of trials, the number of channels & the number of time-points, respectively. fmri_data : array The fmri data. The shape of fmri_data must be [n_cons, n_subs, n_chls, nx, ny, nz]. n_cons, n_chls, nx, ny, nz represent the number of conidtions, the number of channels & the size of fMRI-img, respectively. chl_opt : int 0 or 1. Default is 0. Calculate the RDM & similarities for each channel or not. If chl_opt=0, calculating based on all channels' data. If chl_opt=1, calculating based on each channel's data respectively. ksize : array or list [kx, ky, kz]. Default is [3, 3, 3]. The size of the fMRI-img. nx, ny, nz represent the number of voxels along the x, y, z axis. strides : array or list [sx, sy, sz]. Default is [1, 1, 1]. The strides for calculating along the x, y, z axis. method : string 'spearman' or 'pearson' or 'kendall' or 'similarity' or 'distance'. Default is 'spearman'. The method to calculate the similarities. If method='spearman', calculate the Spearman Correlations. If method='pearson', calculate the Pearson Correlations. If methd='kendall', calculate the Kendall tau Correlations. If method='similarity', calculate the Cosine Similarities. If method='distance', calculate the Euclidean Distances. rescale : bool True or False. Rescale the values in RDM or not. Here, the maximum-minimum method is used to rescale the values except for the values on the diagonal. Returns ------- corrs : array The similarities between EEG/MEG/fNIRS data and fMRI data for searchlight. If chl_opt=1, the shape of RDMs is [n_chls, n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. If chl_opt=0, the shape of RDMs is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value. """ # get the size of the fMRI-img nx = np.shape(fmri_data)[2] ny = np.shape(fmri_data)[3] nz = np.shape(fmri_data)[4] # the size of the calculation units for searchlight kx = ksize[0] ky = ksize[1] kz = ksize[2] # strides for calculating along the x, y, z axis sx = strides[0] sy = strides[1] sz = strides[0] # calculate the number of the calculation units in the x, y, z directions n_x = int((nx - kx) / sx) + 1 n_y = int((ny - ky) / sy) + 1 n_z = int((nz - kz) / sz) + 1 # calculate the fmri_rdms for searchlight fmri_rdms = fmriRDM(fmri_data, ksize=ksize, strides=strides) # chl_opt=1 if chl_opt == 1: # get the number of channels chls = np.shape(eeg_data)[3] # get the eeg_rdms eeg_rdms = eegRDM(eeg_data, sub_opt=0, chl_opt=1, time_opt=0) # initialize the corrs corrs = np.full([chls, n_x, n_y, n_z, 2], np.nan) # calculate the corrs for j in range(n_x): for k in range(n_y): for l in range(n_z): for i in range(chls): if method == "spearman": corrs[i, j, k, l] = rdm_correlation_spearman( eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "pearson": corrs[i, j, k, l] = rdm_correlation_pearson(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "kendall": corrs[i, j, k, l] = rdm_correlation_kendall(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "similarity": corrs[i, j, k, l, 0] = rdm_similarity(eeg_rdms[i], fmri_rdms[j, k, l], rescale=rescale) elif method == "distance": corrs[i, j, k, l, 0] = rdm_distance(eeg_rdms[i], fmri_rdms[i, j, k], rescale=rescale) return np.abs(corrs) # chl_opt=0 # get the eeg_rdms eeg_rdm = eegRDM(eeg_data, sub_opt=0, chl_opt=0, time_opt=0) # initialize the corrs corrs = np.full([n_x, n_y, n_z, 2], np.nan) # calculate the corrs for i in range(n_x): for j in range(n_y): for k in range(n_z): if method == "spearman": corrs[i, j, k] = rdm_correlation_spearman(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "pearson": corrs[i, j, k] = rdm_correlation_pearson(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "kendall": corrs[i, j, k] = rdm_correlation_kendall(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "similarity": corrs[i, j, k, 0] = rdm_similarity(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) elif method == "distance": corrs[i, j, k, 0] = rdm_distance(eeg_rdm, fmri_rdms[i, j, k], rescale=rescale) return np.abs(corrs)
# Plot the RDM of 0ms, 50ms, 100ms, 150ms, 200ms times = [10, 20, 30, 40, 50] for t in times: plot_rdm(rdms[t], rescale=True) #%% 对比两个rdm之间的相似性,只有一个值出来(想到MVPA的那个图) """********** Section 6: Calculating the Similarity between two RDMs **********""" # RDM of 200ms rdm_sample1 = rdms[30] # RDM of 800ms rdm_sample2 = rdms[90] # calculate the correlation coefficient between these two RDMs # r p值都有 corr = rdm_correlation_spearman(rdm_sample1, rdm_sample2, rescale=True) print(corr) #%% """********** Section 7: Calculating the Similarity and Plotting **********""" # Calculate the representational similarity between 200ms and all the time points # 这个思路就清晰了!自己设计的rdm和真实情况的rdm进行对比 # 到时候你算的时候就……也是先算好rdms,然后再用一个去对比 corrs1 = rdms_corr(rdm_sample1, rdms) # Plot the corrs1 corrs1 = np.reshape(corrs1, [1, 110, 2]) plot_corrs_by_time(corrs1, time_unit=[-0.1, 0.01]) # Calculate and Plot multi-corrs
""" import numpy as np from neurora.rdm_corr import rdm_correlation_spearman model_rdm = np.loadtxt("../codingmodel_rdm/ori_rdm.txt") for sub in range(6): eegrdms = np.loadtxt("../eegrdm/theta_power_po/sub" + str(sub + 1) + ".txt") eegrdms = np.reshape(eegrdms, [851, 18, 18]) sub_corrs = np.zeros([851, 2], dtype=np.float) for i in range(851): sub_corrs[i] = rdm_correlation_spearman(model_rdm, eegrdms[i]) np.savetxt("corrs/theta_power_po/ori_subs" + str(sub + 1) + ".txt", sub_corrs) model_rdm = np.loadtxt("../codingmodel_rdm/pos_rdm.txt") for sub in range(6): eegrdms = np.loadtxt("../eegrdm/theta_power_po/sub" + str(sub + 1) + ".txt") eegrdms = np.reshape(eegrdms, [851, 18, 18]) sub_corrs = np.zeros([851, 2], dtype=np.float) for i in range(851): sub_corrs[i] = rdm_correlation_spearman(model_rdm, eegrdms[i])