我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.corrcoef()。
def get_dist_func(name): """ Valid names: Euclidean Pearson """ if name == 'Euclidean': if EUC_C_EXT_ENABLED: return euclidean.euclidean else: return euc elif name == 'Pearson': #FIXME: Until I write my own c-extension, this is as good as it gets. And it's SLOW. return lambda x, y: 1 - numpy.corrcoef(x,y)[0][1] #Again, we normalise -1 to distant and 1 to close. corrcoef returns the correlation matrix. else: raise ValueError, 'No distance function named: %s' % name
def _init_coefs(X, method='corrcoef'): if method == 'corrcoef': return np.corrcoef(X, rowvar=False), 1.0 elif method == 'cov': init_cov = np.cov(X, rowvar=False) return init_cov, np.max(np.abs(np.triu(init_cov))) elif method == 'spearman': return spearman_correlation(X, rowvar=False), 1.0 elif method == 'kendalltau': return kendalltau_correlation(X, rowvar=False), 1.0 elif callable(method): return method(X) else: raise ValueError( ("initialize_method must be 'corrcoef' or 'cov', " "passed \'{}\' .".format(method)) )
def test_2d_w_missing(self): # Test corrcoef on 2D variable w/ missing value x = self.data x[-1] = masked x = x.reshape(3, 4) test = corrcoef(x) control = np.corrcoef(x) assert_almost_equal(test[:-1, :-1], control[:-1, :-1]) with catch_warn_mae(): warnings.simplefilter("ignore") # ddof and bias have no or negligible effect on the function assert_almost_equal(corrcoef(x, ddof=-2)[:-1, :-1], control[:-1, :-1]) assert_almost_equal(corrcoef(x, ddof=3)[:-1, :-1], control[:-1, :-1]) assert_almost_equal(corrcoef(x, bias=1)[:-1, :-1], control[:-1, :-1])
def test_individual_stability_matrix(): """ Tests individual_stability_matrix method on three gaussian blobs. """ import utils import numpy as np import scipy as sp desired = np.load(home + '/git_repo/PyBASC/tests/ism_test.npy') blobs = generate_blobs() ism = utils.individual_stability_matrix(blobs, 20, 3) #how to use test here? # np.corrcoef(ism.flatten(),desired.flatten()) # np.testing.assert_equal(ism,desired) # # corr=np.array(sp.spatial.distance.cdist(ism, desired, metric = 'correlation')) # assert False
def plot_trace(n=0, lg=False): plt.plot(trueC[n], c=col[2], clip_on=False, zorder=5, label='Truth') plt.plot(solution, c=col[0], clip_on=False, zorder=7, label='Estimate') plt.plot(y, c=col[7], alpha=.7, lw=1, clip_on=False, zorder=-10, label='Data') if lg: plt.legend(frameon=False, ncol=3, loc=(.1, .62), columnspacing=.8) spks = np.append(0, solution[1:] - g * solution[:-1]) plt.text(800, 2.2, 'Correlation: %.3f' % (np.corrcoef(trueSpikes[n], spks)[0, 1]), size=24) plt.gca().set_xticklabels([]) simpleaxis(plt.gca()) plt.ylim(0, 2.85) plt.xlim(0, 1500) plt.yticks([0, 2], [0, 2]) plt.xticks([300, 600, 900, 1200], ['', '']) # init params
def pred_accuracy(y_true, y_pred): y_true = sp.copy(y_true) if len(sp.unique(y_true))==2: print 'dichotomous trait, calculating AUC' y_min = y_true.min() y_max = y_true.max() if y_min!= 0 or y_max!=1: y_true[y_true==y_min]=0 y_true[y_true==y_max]=1 fpr, tpr, thresholds = metrics.roc_curve(y_true, y_pred) auc = metrics.auc(fpr, tpr) return auc else: print 'continuous trait, calculating COR' cor = sp.corrcoef(y_true,y_pred)[0,1] return cor
def calculate_residual_correlation_matrix(returns): # find the market return constraining on the selected companies (first PCA) # regress each stock on that and find correlation of residuals returns_matrix = returns.as_matrix().transpose() covar_matrix = np.cov(returns_matrix) pca = decomposition.PCA(n_components=1) pca.fit(covar_matrix) X = pca.transform(covar_matrix) regr = linear_model.LinearRegression() dim = covar_matrix.shape[1] res = np.zeros(shape=(dim,dim)) for x in range(0, dim): regr = linear_model.LinearRegression() regr = regr.fit(X, covar_matrix[:,x]) res[:,x] = covar_matrix[:,x] - regr.predict(X) res_corr = np.corrcoef(res) return pd.DataFrame(res_corr, index = returns.columns, columns = returns.columns)
def all_correlations_fast_no_scipy(y, X): ''' Cs = all_correlations(y, X) Cs[i] = np.corrcoef(y, X[i])[0,1] ''' X = np.asanyarray(X, float) y = np.asanyarray(y, float) xy = np.dot(X, y) y_ = y.mean() ys_ = y.std() x_ = X.mean(1) xs_ = X.std(1) n = float(len(y)) ys_ += 1e-5 # Handle zeros in ys xs_ += 1e-5 # Handle zeros in x return (xy - x_ * y_ * n) / n / xs_ / ys_
def test_learn_codes(): """Test learning of codes.""" thresh = 0.25 X, ds, z = simulate_data(n_trials, n_times, n_times_atom, n_atoms) for solver in ('l_bfgs', 'ista', 'fista'): z_hat = update_z(X, ds, reg, n_times_atom, solver=solver, solver_kwargs=dict(factr=1e11, max_iter=50)) X_hat = construct_X(z_hat, ds) assert_true(np.corrcoef(X.ravel(), X_hat.ravel())[1, 1] > 0.99) assert_true(np.max(X - X_hat) < 0.1) # Find position of non-zero entries idx = np.ravel_multi_index(z[0].nonzero(), z[0].shape) loc_x, loc_y = np.where(z_hat[0] > thresh) # shift position by half the length of atom idx_hat = np.ravel_multi_index((loc_x, loc_y), z_hat[0].shape) # make sure that the positions are a subset of the positions # in the original z mask = np.in1d(idx_hat, idx) assert_equal(np.sum(mask), len(mask))
def get_corr_func(method): if method in ['kendall', 'spearman']: from scipy.stats import kendalltau, spearmanr def _pearson(a, b): return np.corrcoef(a, b)[0, 1] def _kendall(a, b): rs = kendalltau(a, b) if isinstance(rs, tuple): return rs[0] return rs def _spearman(a, b): return spearmanr(a, b)[0] _cor_methods = { 'pearson': _pearson, 'kendall': _kendall, 'spearman': _spearman } return _cor_methods[method]
def correlation_valid(x, y): invalid = numpy.logical_or(numpy.isnan(x), numpy.isnan(y)) valid = numpy.logical_not(invalid) valid_count = valid.sum() if valid_count == 0: corr = float('nan') sd_x = float('nan') sd_y = float('nan') else: sd_x = numpy.std(x[valid]) sd_y = numpy.std(y[valid]) if sd_x == 0 and sd_y == 0: corr = 1.0 elif sd_x == 0 or sd_y == 0: corr = 0.0 else: corr = numpy.corrcoef(x[valid], y[valid])[0,1] return corr, valid_count, sd_x, sd_y
def findcorrelation(self, A, B, k): ''' Construct k by k matrix of Pearson product-moment correlation coefficients for every combination of two columns in A and B :param: A : first NMF solution matrix :param: B : second NMF solution matrix, of same dimensions as A :param: k : number of columns in each matrix A and B Return: numpy array of dimensions k by k, where array[a][b] is the correlation between column 'a' of X and column 'b' Usage: Called by instability() ''' corrmatrix = [] for a in range(k): for b in range(k): c = np.corrcoef(A[:, a], B[:, b]) corrmatrix.append(c[0][1]) return np.asarray(corrmatrix).reshape(k, k)
def th_corrcoef(x): """ mimics np.corrcoef """ # calculate covariance matrix of rows mean_x = th.mean(x, 1) xm = x.sub(mean_x.expand_as(x)) c = xm.mm(xm.t()) c = c / (x.size(1) - 1) # normalize covariance matrix d = th.diag(c) stddev = th.pow(d, 0.5) c = c.div(stddev.expand_as(c)) c = c.div(stddev.expand_as(c).t()) # clamp between -1 and 1 c = th.clamp(c, -1.0, 1.0) return c
def visualize_housing_data(df): sns.set(style='whitegrid', context='notebook') cols = ['LSTAT', 'INDUS', 'NOX', 'RM', 'MEDV'] sns.pairplot(df[cols], size=2.5) plt.show() correlation_matrix = np.corrcoef(df[cols].values.T) sns.set(font_scale=1.5) heatmap = sns.heatmap( correlation_matrix, cbar=True, annot=True, square=True, fmt='.2f', annot_kws={'size': 15}, yticklabels=cols, xticklabels=cols, ) plt.show()
def test_2d_with_missing(self): # Test corrcoef on 2D variable w/ missing value x = self.data x[-1] = masked x = x.reshape(3, 4) test = corrcoef(x) control = np.corrcoef(x) assert_almost_equal(test[:-1, :-1], control[:-1, :-1]) with suppress_warnings() as sup: sup.filter(DeprecationWarning, "bias and ddof have no effect") # ddof and bias have no or negligible effect on the function assert_almost_equal(corrcoef(x, ddof=-2)[:-1, :-1], control[:-1, :-1]) assert_almost_equal(corrcoef(x, ddof=3)[:-1, :-1], control[:-1, :-1]) assert_almost_equal(corrcoef(x, bias=1)[:-1, :-1], control[:-1, :-1])
def test_compute_corr(): """Test Anscombe's Quartett """ x = np.array([10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5]) y = np.array([[8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68], [9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74], [7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73], [8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8], [6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89]]) r = compute_corr(x, y.T) r2 = np.array([np.corrcoef(x, y[i])[0, 1] for i in range(len(y))]) assert_allclose(r, r2) assert_raises(ValueError, compute_corr, [1, 2], [])
def buildCorrelationEntries(self, name, gene, weight_db_logic, snps_by_rsid): weights_in_gene = weight_db_logic.weights_by_gene[gene] rsids_from_genes = weights_in_gene.keys() #gather as much data as we can work on related_rsids, related_data = self.buildRelatedData(rsids_from_genes, snps_by_rsid, weights_in_gene) if len(related_rsids) == 0: return [] self.updateFoundCorrelation(gene, name) #correlation matrix of related SNP's data array = numpy.array(related_data) cor = numpy.corrcoef(array) #translate into sql entries entries = self.buildMatrixOutputEntries(cor, rsids_from_genes, related_rsids, snps_by_rsid) if not len(entries): raise NameError("Couldn not build correlation entries for (%s,%s)" %(name,gene)) return entries
def testLocallyWeightedRegression(): datasArr, valuessArr = loadDataSet('datasets/ex0.txt') m = np.shape(datasArr)[0] predictValues = np.zeros(m) for i in range(0, m): predictValues[i] = \ locallyWeightedRegression(datasArr[i], datasArr, valuessArr, 0.01) # ?????? xMat = np.matrix(datasArr) valueMat = np.matrix(valuessArr) plt.figure(figsize=(10, 10), facecolor="white") plt.subplot(111) plt.scatter(xMat[:, 1].flatten().A[0], valueMat.T.flatten().A[0]) # ??????? # ?????????? sortedIndexs = xMat[:, 1].argsort(0) print "sortedIndexs:" print sortedIndexs sortedMat = xMat[sortedIndexs.flatten().A[0]] plt.plot(sortedMat[:, 1], predictValues[sortedIndexs], c='red', linewidth=2) plt.show() # ????????????? correlationCoefficients = np.corrcoef(predictValues, valueMat) print "?????", correlationCoefficients
def rsq(self, tmin=None, tmax=None): """Correlation between observed and simulated series. Notes ----- For the calculation of this statistic the corrcoef method from numpy is used. >>> np.corrcoef(sim, obs)[0, 1] Please refer to the Numpy Docs: https://docs.scipy.org/doc/numpy/reference/generated/numpy.corrcoef.html#numpy.corrcoef """ sim = self.ml.simulate(tmin=tmin, tmax=tmax) obs = self.ml.observations(tmin=tmin, tmax=tmax) sim = sim[obs.index] # Make sure to correlate the same in time. return np.corrcoef(sim, obs)[0, 1]
def PA(samples, variables): datasets = 5000 eig_vals = [] for i in range(datasets): data = np.random.standard_normal((variables, samples)) cor_ = np.corrcoef(data) eig_vals.append(np.sort(np.linalg.eig(cor_)[0])[::-1]) quantile = (np.round(np.percentile(eig_vals, 95.0, axis=0), 4)) mean_ = (np.round(np.mean(eig_vals, axis=0), 4)) return quantile
def PCAdo(block, name): cor_ = np.corrcoef(block.T) eig_vals, eig_vecs = np.linalg.eig(cor_) tot = sum(eig_vals) var_exp = [(i / tot) * 100 for i in sorted(eig_vals, reverse=True)] cum_var_exp = np.cumsum(var_exp) loadings = (eig_vecs * np.sqrt(eig_vals)) eig_vals = np.sort(eig_vals)[::-1] print('Eigenvalues') print(eig_vals) print('Variance Explained') print(var_exp) print('Total Variance Explained') print(cum_var_exp) print('Loadings') print(abs(loadings[:, 0])) PAcorrect = PA(block.shape[0], block.shape[1]) print('Parallel Analisys') pa = (eig_vals - (PAcorrect - 1)) print(pa) print('Correlation Matrix') print(pd.DataFrame.corr(block)) plt.plot(range(1,len(pa)+1), pa, '-o') plt.grid(True) plt.xlabel('Fatores') plt.ylabel('Componentes') plt.savefig('imgs/PCA' + name, bbox_inches='tight') plt.clf() plt.cla() # plt.show()
def pearson_r(data_1, data_2): return np.corrcoef(data_1, data_2)[0,1]
def person_sim(cls, x, y): return 0.5 + 0.5 * np.corrcoef(x, y, rowvar=0)[0][1]
def test_pearson_r(data): x, y = data if np.allclose(x, x[0], atol=atol, equal_nan=True) or np.allclose(y, y[0], atol=atol, equal_nan=True): assert np.isnan(dcst.pearson_r(x, y)) else: assert np.isclose(dcst.pearson_r(x, y), original.pearson_r(x, y)) assert np.isclose(dcst.pearson_r(x, y), np.corrcoef(x, y)[0,1])
def pearson_r(x, y): """Compute Pearson correlation coefficient between two arrays.""" # Compute correlation matrix corr_mat = np.corrcoef(x, y) # Return entry [0,1] return corr_mat[0,1]
def transform_to_correlation_dist(data): y_corr = np.corrcoef(data.T) # we just need the magnitude of the correlation and don't care whether it's positive or not abs_corr = np.abs(y_corr) return np.nan_to_num(abs_corr)
def transform_to_positive_corrs(data, sun_idx): y_corr = np.corrcoef(data.T) positive = y_corr[sun_idx] positive = positive >= 0 return positive
def AR1(constrained=False): g = .95 sn = .3 y, c, s = [a[0] for a in gen_data([g], sn, N=1)] result = constrained_oasisAR1(y, g, sn) if constrained else oasisAR1(y, g, lam=2.4) result_foopsi = constrained_foopsi(y, [g], sn) if constrained else foopsi(y, [g], lam=2.4) npt.assert_allclose(np.corrcoef(result[0], result_foopsi[0])[0, 1], 1) npt.assert_allclose(np.corrcoef(result[1], result_foopsi[1])[0, 1], 1) npt.assert_allclose(np.corrcoef(result[0], c)[0, 1], 1, .03) npt.assert_allclose(np.corrcoef(result[1], s)[0, 1], 1, .2)
def AR2(constrained=False): g = [1.7, -.712] sn = .3 y, c, s = [a[0] for a in gen_data(g, sn, N=1, seed=3)] result = constrained_onnlsAR2(y, g, sn) if constrained else onnls(y, g, lam=25) result_foopsi = constrained_foopsi(y, g, sn) if constrained else foopsi(y, g, lam=25) npt.assert_allclose(np.corrcoef(result[0], result_foopsi[0])[0, 1], 1, 1e-3) npt.assert_allclose(np.corrcoef(result[1], result_foopsi[1])[0, 1], 1, 1e-2) npt.assert_allclose(np.corrcoef(result[0], c)[0, 1], 1, .03) npt.assert_allclose(np.corrcoef(result[1], s)[0, 1], 1, .2) result2 = constrained_oasisAR2(y, g[0], g[1], sn) if constrained \ else oasisAR2(y, g[0], g[1], lam=25) npt.assert_allclose(np.corrcoef(result2[0], c)[0, 1], 1, .03) npt.assert_allclose(np.corrcoef(result2[1], s)[0, 1], 1, .2)
def test_non_array(self): assert_almost_equal(np.corrcoef([0, 1, 0], [1, 0, 1]), [[1., -1.], [-1., 1.]])
def test_simple(self): tgt1 = corrcoef(self.A) assert_almost_equal(tgt1, self.res1) assert_(np.all(np.abs(tgt1) <= 1.0)) tgt2 = corrcoef(self.A, self.B) assert_almost_equal(tgt2, self.res2) assert_(np.all(np.abs(tgt2) <= 1.0))
def test_ddof(self): # ddof raises DeprecationWarning with catch_warn_nfb(): warnings.simplefilter("always") assert_warns(DeprecationWarning, corrcoef, self.A, ddof=-1) warnings.simplefilter("ignore") # ddof has no or negligible effect on the function assert_almost_equal(corrcoef(self.A, ddof=-1), self.res1) assert_almost_equal(corrcoef(self.A, self.B, ddof=-1), self.res2) assert_almost_equal(corrcoef(self.A, ddof=3), self.res1) assert_almost_equal(corrcoef(self.A, self.B, ddof=3), self.res2)
def test_bias(self): # bias raises DeprecationWarning with catch_warn_nfb(): warnings.simplefilter("always") assert_warns(DeprecationWarning, corrcoef, self.A, self.B, 1, 0) assert_warns(DeprecationWarning, corrcoef, self.A, bias=0) warnings.simplefilter("ignore") # bias has no or negligible effect on the function assert_almost_equal(corrcoef(self.A, bias=1), self.res1)
def test_complex(self): x = np.array([[1, 2, 3], [1j, 2j, 3j]]) res = corrcoef(x) tgt = np.array([[1., -1.j], [1.j, 1.]]) assert_allclose(res, tgt) assert_(np.all(np.abs(res) <= 1.0))
def test_empty(self): with warnings.catch_warnings(record=True): warnings.simplefilter('always', RuntimeWarning) assert_array_equal(corrcoef(np.array([])), np.nan) assert_array_equal(corrcoef(np.array([]).reshape(0, 2)), np.array([]).reshape(0, 0)) assert_array_equal(corrcoef(np.array([]).reshape(2, 0)), np.array([[np.nan, np.nan], [np.nan, np.nan]]))
def test_extreme(self): x = [[1e-100, 1e100], [1e100, 1e-100]] with np.errstate(all='raise'): c = corrcoef(x) assert_array_almost_equal(c, np.array([[1., -1.], [-1., 1.]])) assert_(np.all(np.abs(c) <= 1.0))
def test_ddof(self): # ddof raises DeprecationWarning x, y = self.data, self.data2 expected = np.corrcoef(x) expected2 = np.corrcoef(x, y) with catch_warn_mae(): warnings.simplefilter("always") assert_warns(DeprecationWarning, corrcoef, x, ddof=-1) warnings.simplefilter("ignore") # ddof has no or negligible effect on the function assert_almost_equal(np.corrcoef(x, ddof=0), corrcoef(x, ddof=0)) assert_almost_equal(corrcoef(x, ddof=-1), expected) assert_almost_equal(corrcoef(x, y, ddof=-1), expected2) assert_almost_equal(corrcoef(x, ddof=3), expected) assert_almost_equal(corrcoef(x, y, ddof=3), expected2)
def test_bias(self): x, y = self.data, self.data2 expected = np.corrcoef(x) # bias raises DeprecationWarning with catch_warn_mae(): warnings.simplefilter("always") assert_warns(DeprecationWarning, corrcoef, x, y, True, False) assert_warns(DeprecationWarning, corrcoef, x, y, True, True) assert_warns(DeprecationWarning, corrcoef, x, bias=False) warnings.simplefilter("ignore") # bias has no or negligible effect on the function assert_almost_equal(corrcoef(x, bias=1), expected)
def test_1d_wo_missing(self): # Test cov on 1D variable w/o missing values x = self.data assert_almost_equal(np.corrcoef(x), corrcoef(x)) assert_almost_equal(np.corrcoef(x, rowvar=False), corrcoef(x, rowvar=False)) with catch_warn_mae(): warnings.simplefilter("ignore") assert_almost_equal(np.corrcoef(x, rowvar=False, bias=True), corrcoef(x, rowvar=False, bias=True))
def test_1d_w_missing(self): # Test corrcoef 1 1D variable w/missing values x = self.data x[-1] = masked x -= x.mean() nx = x.compressed() assert_almost_equal(np.corrcoef(nx), corrcoef(x)) assert_almost_equal(np.corrcoef(nx, rowvar=False), corrcoef(x, rowvar=False)) with catch_warn_mae(): warnings.simplefilter("ignore") assert_almost_equal(np.corrcoef(nx, rowvar=False, bias=True), corrcoef(x, rowvar=False, bias=True)) try: corrcoef(x, allow_masked=False) except ValueError: pass # 2 1D variables w/ missing values nx = x[1:-1] assert_almost_equal(np.corrcoef(nx, nx[::-1]), corrcoef(x, x[::-1])) assert_almost_equal(np.corrcoef(nx, nx[::-1], rowvar=False), corrcoef(x, x[::-1], rowvar=False)) with catch_warn_mae(): warnings.simplefilter("ignore") # ddof and bias have no or negligible effect on the function assert_almost_equal(np.corrcoef(nx, nx[::-1]), corrcoef(x, x[::-1], bias=1)) assert_almost_equal(np.corrcoef(nx, nx[::-1]), corrcoef(x, x[::-1], ddof=2))
def ncc(ypred, y): return np.corrcoef(ypred, y)[1,0]
def test_convergence(self): size = 100 buf = prioritized.PrioritizedBuffer(capacity=size) for x in range(size): buf.append(x) priority_init = list(range(size)) random.shuffle(priority_init) count_sampled = [0] * size def priority(x, n): return priority_init[x] + 1 / count_sampled[x] count_none = 0 for t in range(200): sampled, probabilities = buf.sample(16) if all([p is not None for p in probabilities]): priority_old = [priority(x, count_sampled[x]) for x in sampled] # assert: probabilities \propto priority_old qs = [x / y for x, y in zip(probabilities, priority_old)] for q in qs: self.assertAlmostEqual(q, qs[0]) else: count_none += 1 for x in sampled: count_sampled[x] += 1 priority_new = [priority(x, count_sampled[x]) for x in sampled] buf.set_last_priority(priority_new) for cnt in count_sampled: self.assertGreaterEqual(cnt, 1) self.assertLessEqual(count_none, size // 16 + 1) corr = np.corrcoef(np.array([priority_init, count_sampled]))[0, 1] self.assertGreater(corr, 0.8)
def corr2_coeff(AB,msk,myrad,bcast_var): if not np.all(msk): return None A,B = (AB[0], AB[1]) A = A.reshape((-1,A.shape[-1])) B = B.reshape((-1,B.shape[-1])) corrAB = np.corrcoef(A.T,B.T)[16:,:16] classical_within = np.mean(corrAB[0:8,0:8]) jazz_within = np.mean(corrAB[8:16,8:16]) classJazz_between = np.mean(corrAB[8:16,0:8]) jazzClass_between = np.mean(corrAB[0:8,8:16]) within_genre = np.mean([classical_within,jazz_within]) between_genre = np.mean([classJazz_between,jazzClass_between]) diff = within_genre - between_genre return diff
def cross_correlation(data1, data2): """ :param data1: :param data2: :return: """ # correlation test corr_min = 1.0 corr_mat = np.corrcoef(data1, data2) corr = np.min(corr_mat) corr_min = min(corr, corr_min) return corr_min
def apply(self, data): return np.corrcoef(data)
def compute_PCC(A, B, masks=None): """Computes the Pearson product-moment correlation coefficients (PCC) for the two images. Parameters ------------- A,B : ndarray The two images to be compared masks : list of ndarrays, optional If supplied, the data under each mask is computed separately. Returns ---------------- covariances : array, list of arrays """ covariances = [] if masks is None: data = np.vstack((np.ravel(A), np.ravel(B))) return np.corrcoef(data) for m in masks: weights = m[m > 0] masked_B = B[m > 0] masked_A = A[m > 0] data = np.vstack((masked_A, masked_B)) # covariances.append(np.cov(data,aweights=weights)) covariances.append(np.corrcoef(data)) return covariances
