def precisionCol(cleandata, k): """Using precision matrix to choose useful attributes in high dimensional data""" model = ShrunkCovariance() model.fit(cleandata) pre_ = pd.DataFrame(model.get_precision()) pre_.index = cleandata.columns pre_.columns = cleandata.columns test = abs(pre_['Y']) test.sort() test = test[-k:] coltest = (test.index).drop('Y') return coltest
def shrinked_covariance(returns, price_data=False, shrinkage_type='basic', assume_centered=False, basic_shrinkage=0.1): """ Calculates the Covariance estimator with shrinkage for a dataframe of asset prices or returns. This function allows three types of shrinkage - Basic, Ledoit-Wolf and Oracle Approximating Shrinkage. It is a wrap of the sklearn's ShrunkCovariance, LedoitWolf and OAS classes. According to the scikit-learn User Guide on Covariance estimation: "Sometimes, it even occurs that the empirical covariance matrix cannot be inverted for numerical reasons. To avoid such an inversion problem, a transformation of the empirical covariance matrix has been introduced: the shrinkage. Mathematically, this shrinkage consists in reducing the ratio between the smallest and the largest eigenvalues of the empirical covariance matrix". Link to the documentation: <https://scikit-learn.org/stable/modules/covariance.html>`_ If a dataframe of prices is given, it is transformed into a dataframe of returns using the calculate_returns method from the ReturnsEstimators class. :param returns: (pd.DataFrame) Dataframe where each column is a series of returns or prices for an asset. :param price_data: (bool) Flag if prices of assets are used and not returns. (False by default) :param shrinkage_type: (str) Type of shrinkage to use. (``basic`` by default, ``lw``, ``oas``, ``all``) :param assume_centered: (bool) Flag for data with mean almost, but not exactly zero. (Read documentation for chosen shrinkage class, False by default) :param basic_shrinkage: (float) Between 0 and 1. Coefficient in the convex combination for basic shrinkage. (0.1 by default) :return: (np.array) Estimated covariance matrix. Tuple of covariance matrices if shrinkage_type = ``all``. """ # Calculating the series of returns from series of prices if price_data: # Class with returns calculation function ret_est = ReturnsEstimators() # Calculating returns returns = ret_est.calculate_returns(returns) # Calculating the covariance matrix for the chosen method if shrinkage_type == 'basic': cov_matrix = ShrunkCovariance(assume_centered=assume_centered, shrinkage=basic_shrinkage).fit( returns).covariance_ elif shrinkage_type == 'lw': cov_matrix = LedoitWolf(assume_centered=assume_centered).fit(returns).covariance_ elif shrinkage_type == 'oas': cov_matrix = OAS(assume_centered=assume_centered).fit(returns).covariance_ else: cov_matrix = ( ShrunkCovariance(assume_centered=assume_centered, shrinkage=basic_shrinkage).fit(returns).covariance_, LedoitWolf(assume_centered=assume_centered).fit(returns).covariance_, OAS(assume_centered=assume_centered).fit(returns).covariance_) return cov_matrix
def test_lda_predict(): # Test LDA classification. # This checks that LDA implements fit and predict and returns correct # values for simple toy data. for test_case in solver_shrinkage: solver, shrinkage = test_case clf = LinearDiscriminantAnalysis(solver=solver, shrinkage=shrinkage) y_pred = clf.fit(X, y).predict(X) assert_array_equal(y_pred, y, "solver %s" % solver) # Assert that it works with 1D data y_pred1 = clf.fit(X1, y).predict(X1) assert_array_equal(y_pred1, y, "solver %s" % solver) # Test probability estimates y_proba_pred1 = clf.predict_proba(X1) assert_array_equal((y_proba_pred1[:, 1] > 0.5) + 1, y, "solver %s" % solver) y_log_proba_pred1 = clf.predict_log_proba(X1) assert_allclose( np.exp(y_log_proba_pred1), y_proba_pred1, rtol=1e-6, atol=1e-6, err_msg="solver %s" % solver, ) # Primarily test for commit 2f34950 -- "reuse" of priors y_pred3 = clf.fit(X, y3).predict(X) # LDA shouldn't be able to separate those assert np.any(y_pred3 != y3), "solver %s" % solver clf = LinearDiscriminantAnalysis(solver="svd", shrinkage="auto") with pytest.raises(NotImplementedError): clf.fit(X, y) clf = LinearDiscriminantAnalysis(solver="lsqr", shrinkage=0.1, covariance_estimator=ShrunkCovariance()) with pytest.raises( ValueError, match=("covariance_estimator and shrinkage " "parameters are not None. " "Only one of the two can be set."), ): clf.fit(X, y) # test bad solver with covariance_estimator clf = LinearDiscriminantAnalysis(solver="svd", covariance_estimator=LedoitWolf()) with pytest.raises(ValueError, match="covariance estimator is not supported with svd"): clf.fit(X, y) # test bad covariance estimator clf = LinearDiscriminantAnalysis(solver="lsqr", covariance_estimator=KMeans( n_clusters=2, n_init="auto")) with pytest.raises(ValueError): clf.fit(X, y)
def compute_connectivity_subject(conn, masker, func, confound=None): """ Returns connectivity of one fMRI for a given atlas """ ts = do_mask_img(masker, func, confound) if conn == 'gl': fc = GraphLassoCV(max_iter=1000) elif conn == 'lw': fc = LedoitWolf() elif conn == 'oas': fc = OAS() elif conn == 'scov': fc = ShrunkCovariance() fc = Bunch(covariance_=0, precision_=0) if conn == 'corr' or conn == 'pcorr': fc = Bunch(covariance_=0, precision_=0) fc.covariance_ = np.corrcoef(ts) fc.precision_ = partial_corr(ts) else: fc.fit(ts) ind = np.tril_indices(ts.shape[1], k=-1) return fc.covariance_[ind], fc.precision_[ind]
def compute_network_connectivity_subject(conn, func, masker, rois): """ Returns connectivity of one fMRI for a given atlas """ ts = masker.fit_transform(func) ts = np.asarray(ts)[:, rois] if conn == 'gl': fc = GraphLassoCV(max_iter=1000) elif conn == 'lw': fc = LedoitWolf() elif conn == 'oas': fc = OAS() elif conn == 'scov': fc = ShrunkCovariance() fc = Bunch(covariance_=0, precision_=0) if conn == 'corr' or conn == 'pcorr': fc = Bunch(covariance_=0, precision_=0) fc.covariance_ = np.corrcoef(ts) fc.precision_ = partial_corr(ts) else: fc.fit(ts) ind = np.tril_indices(ts.shape[1], k=-1) return fc.covariance_[ind], fc.precision_[ind]
def get_covariances(samples): estimators = [ShrunkCovariance(assume_centered=False).fit(samples[:, n]) for n in range(samples.shape[1])] covariances = [x.covariance_ for x in estimators] inv_covariances = [x.precision_ for x in estimators] # by chain (could average across galaxies?) # covariances = [np.maximum(x, x.transpose()) for x in raw_covariances] # force symmetric, may not be needed # raw_inv_covariances = [linalg.inv(x) for x in raw_covariances] # inv_covariances = [np.maximum(x, x.transpose()) for x in raw_inv_covariances] # force symmetric, may not be needed return covariances, inv_covariances
def __init__(self, template, shrinkage='oas', center=True, cov_i=None): self.template = np.asarray(template).ravel()[:, np.newaxis] self.center = center if center: self.template -= self.template.mean() if shrinkage == 'oas': self.cov = OAS() elif shrinkage == 'lw': self.cov = LedoitWolf() elif shrinkage == 'none': self.cov = EmpiricalCovariance() elif type(shrinkage) == float or type(shrinkage) == int: self.cov = ShrunkCovariance(shrinkage=shrinkage) else: raise ValueError('Invalid value for shrinkage parameter.') self.cov_i = cov_i
def test_oas(): """Tests OAS module on a simple dataset. """ # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X, assume_centered=True) assert_almost_equal(oa.shrinkage_, 0.018740, 4) assert_almost_equal(oa.score(X, assume_centered=True), -5.03605, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X, assume_centered=True) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 oa = OAS() oa.fit(X_1d, assume_centered=True) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal((X_1d ** 2).sum() / n_samples, oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X, assume_centered=True) assert_almost_equal(oa.score(X, assume_centered=True), -5.03605, 4) assert(oa.precision_ is None) ### Same tests without assuming centered data # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X) assert_almost_equal(oa.shrinkage_, 0.020236, 4) assert_almost_equal(oa.score(X), 2.079025, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 oa = OAS() oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X) assert_almost_equal(oa.score(X), 2.079025, 4) assert(oa.precision_ is None)
def get_cov_estimator(cov_type): if cov_type == 'LW': model = LedoitWolf() elif cov_type == 'OAS': model = OAS() elif cov_type == 'MCD': model = MinCovDet() elif cov_type[:2] == 'SC': shrinkage = float(cov_type.split('_')[1]) model = ShrunkCovariance(shrinkage=shrinkage) elif cov_type[:2] == 'GL': alpha = float(cov_type.split('_')[1]) model = GraphicalLasso(alpha=alpha) return model
def __init__(self, template, shrinkage='oas', center=True): self.template = template self.template = np.asarray(template).flatten()[:, np.newaxis] self.center = center if center: self.template -= self.template.mean() if shrinkage == 'oas': self.cov = OAS elif shrinkage == 'lw': self.cov = LedoitWolf elif shrinkage == 'none': self.cov = EmpiricalCovariance elif type(shrinkage) == float or type(shrinkage) == int: self.cov = ShrunkCovariance(shrinkage=shrinkage)
def test_lda_shrinkage(seed): # Test that shrunk covariance estimator and shrinkage parameter behave the # same rng = np.random.RandomState(seed) X = rng.rand(100, 10) y = rng.randint(3, size=(100)) c1 = LinearDiscriminantAnalysis(store_covariance=True, shrinkage=0.5, solver="lsqr") c2 = LinearDiscriminantAnalysis( store_covariance=True, covariance_estimator=ShrunkCovariance(shrinkage=0.5), solver="lsqr") c1.fit(X, y) c2.fit(X, y) assert_allclose(c1.means_, c2.means_) assert_allclose(c1.covariance_, c2.covariance_)
def estimate_covariance(x, method): """ Covariance estimator wrapper :param x: :param method: :return: """ cov = None if method == 'shrunk': cov = ShrunkCovariance().fit(x) elif method == 'glasso': cov = GraphicalLassoCV(cv=5, alphas=10, n_refinements=10).fit(x) else: ValueError('Covariance method not in [shrunk,glasso]') return cov.covariance_, cov.precision_
def get_stages(self): from sklearn.covariance import (EmpiricalCovariance, EllipticEnvelope, LedoitWolf, MinCovDet, OAS, ShrunkCovariance) from sklearn.preprocessing import StandardScaler, RobustScaler, MinMaxScaler from srom.anomaly_detection.generalized_anomaly_model import GeneralizedAnomalyModel from srom.utils.no_op import NoOp return [ [('skipscaling', NoOp()), ('standardscaler', StandardScaler()), ('robustscaler', RobustScaler()), ('minmaxscaling', MinMaxScaler())], [ # Covariance Structure based Anomaly Models ('empiricalcovariance', GeneralizedAnomalyModel(base_learner=EmpiricalCovariance(), fit_function='fit', predict_function='mahalanobis', score_sign=1)), ('ellipticenvelope', GeneralizedAnomalyModel(base_learner=EllipticEnvelope(), fit_function='fit', predict_function='mahalanobis', score_sign=1)), ('ledoitwolf', GeneralizedAnomalyModel(base_learner=LedoitWolf(), fit_function='fit', predict_function='mahalanobis', score_sign=1)), ('mincovdet', GeneralizedAnomalyModel(base_learner=MinCovDet(), fit_function='fit', predict_function='mahalanobis', score_sign=1)), ('oas', GeneralizedAnomalyModel(base_learner=OAS(), fit_function='fit', predict_function='mahalanobis', score_sign=1)), ('shrunkcovariance', GeneralizedAnomalyModel(base_learner=ShrunkCovariance(), fit_function='fit', predict_function='mahalanobis', score_sign=1)), ] ]
def __init__(self, template, shrinkage='oas', center=True): BaseNode.__init__(self) self.template = template self.template = np.atleast_2d(template) self.center = center if center: self.template -= self.template.mean() if shrinkage == 'oas': self.cov = OAS elif shrinkage == 'lw': self.cov = LedoitWolf elif shrinkage == 'none': self.cov = EmpiricalCovariance elif type(shrinkage) == float or type(shrinkage) == int: self.cov = ShrunkCovariance(shrinkage=shrinkage)
def compute_connectivity_voxel(roi, voxel, conn): """ Returns connectivity of one voxel for a given roi """ if conn == 'gl': fc = GraphLassoCV(max_iter=1000) elif conn == 'lw': fc = LedoitWolf() elif conn == 'oas': fc = OAS() elif conn == 'scov': fc = ShrunkCovariance() ts = np.array([roi, voxel]).T if conn == 'corr' or conn == 'pcorr': cov = np.corrcoef(ts)[0, 1] else: fc.fit(ts) cov = fc.covariance_[0, 0] return cov
def test_ledoit_wolf(): # Tests LedoitWolf module on a simple dataset. # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) lw = LedoitWolf(assume_centered=True) lw.fit(X_centered) shrinkage_ = lw.shrinkage_ score_ = lw.score(X_centered) assert_almost_equal(ledoit_wolf_shrinkage(X_centered, assume_centered=True), shrinkage_) assert_almost_equal(ledoit_wolf_shrinkage(X_centered, assume_centered=True, block_size=6), shrinkage_) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_centered, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf(assume_centered=True) lw.fit(X_1d) lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_1d, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) assert_array_almost_equal((X_1d ** 2).sum() / n_samples, lw.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False, assume_centered=True) lw.fit(X_centered) assert_almost_equal(lw.score(X_centered), score_, 4) assert(lw.precision_ is None) # Same tests without assuming centered data # test shrinkage coeff on a simple data set lw = LedoitWolf() lw.fit(X) assert_almost_equal(lw.shrinkage_, shrinkage_, 4) assert_almost_equal(lw.shrinkage_, ledoit_wolf_shrinkage(X)) assert_almost_equal(lw.shrinkage_, ledoit_wolf(X)[1]) assert_almost_equal(lw.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf() lw.fit(X_1d) lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_1d) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), lw.covariance_, 4) # test with one sample # warning should be raised when using only 1 sample X_1sample = np.arange(5).reshape(1, 5) lw = LedoitWolf() assert_warns(UserWarning, lw.fit, X_1sample) assert_array_almost_equal(lw.covariance_, np.zeros(shape=(5, 5), dtype=np.float64)) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False) lw.fit(X) assert_almost_equal(lw.score(X), score_, 4) assert(lw.precision_ is None)
# generate sample data n_features, n_samples = 40, 20 np.random.seed(42) base_X_train = np.random.normal(size=(n_samples, n_features)) base_X_test = np.random.normal(size=(n_samples, n_features)) # color samples coloring_matrix = np.random.normal(size=(n_features, n_features)) X_train = np.dot(base_X_train, coloring_matrix) X_test = np.dot(base_X_test, coloring_matrix) # compute the likelihood on test data # spanning a range of possible shrinkage coefficient values shrinkages = np.logspace(-2, 0, 30) negative_logliks = [ -ShrunkCovariance(shrinkage=s).fit(X_train).score(X_test) for s in shrinkages ] # under the ground-truth model, which we whould not have # access to in real settings real_cov = np.dot(coloring_matrix.T, coloring_matrix) emp_cov = empirical_covariance(X_train) loglik_real = -log_likelihood(emp_cov, linalg.inv(real_cov)) # compute different approaches to setting the parameter # gridsearch for an optimal shrinkage coefficient tuned_parameters = [ {'shrinkage': shrinkages}
class TemplateBeamformer(BaseNode): ''' Spatio-temporal LCMV beamformer operating on a spatio-temporal template. Parameters ---------- template : 2D array (n_channels, n_samples) Spatio-temporal activation pattern of the component to extract. shrinkage : str | float (default: 'oas') Shrinkage parameter for the covariance matrix inversion. This can either be speficied as a number between 0 and 1, or as a string indicating which automated estimation method to use: 'none': No shrinkage: emperical covariance 'oas': Oracle approximation shrinkage 'lw': Ledoit-Wolf approximation shrinkage center : bool (default: True) Whether to remove the data mean before applying the filter. ''' def __init__(self, template, shrinkage='oas', center=True): BaseNode.__init__(self) self.template = template self.template = np.atleast_2d(template) self.center = center if center: self.template -= self.template.mean() if shrinkage == 'oas': self.cov = OAS elif shrinkage == 'lw': self.cov = LedoitWolf elif shrinkage == 'none': self.cov = EmpiricalCovariance elif type(shrinkage) == float or type(shrinkage) == int: self.cov = ShrunkCovariance(shrinkage=shrinkage) def _center(self, d): data_mean = d.data.reshape(-1, len(d)).mean(axis=1) data_mean = data_mean.reshape(d.feat_shape + (1,)) return DataSet(d.data - data_mean, default=d) def train_(self, d): if self.center: d = self._center(d) nsamples, ntrials = d.data.shape[1:] template = self.template[:, :nsamples] c = self.cov.fit(d.data.reshape(-1, ntrials).T) sigma_x_i = c.precision_ template = self.template.flatten()[:, np.newaxis] self.W = sigma_x_i.dot(template) # Noise normalization self.W = self.W.dot( np.linalg.inv(reduce(np.dot, [template.T, sigma_x_i, template])) ) def apply_(self, d): if self.center: d = self._center(d) ntrials = d.data.shape[2] X = self.W.T.dot(d.data.reshape(-1, ntrials)) return DataSet(data=X, feat_lab=None, default=d)
def test_oas(): # Tests OAS module on a simple dataset. # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) oa = OAS(assume_centered=True) oa.fit(X_centered) shrinkage_ = oa.shrinkage_ score_ = oa.score(X_centered) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_centered, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS(assume_centered=True) oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal((X_1d**2).sum() / n_samples, oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False, assume_centered=True) oa.fit(X_centered) assert_almost_equal(oa.score(X_centered), score_, 4) assert (oa.precision_ is None) # Same tests without assuming centered data-------------------------------- # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X) assert_almost_equal(oa.shrinkage_, shrinkage_, 4) assert_almost_equal(oa.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS() oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4) # test with one sample # FIXME I don't know what this test does X_1sample = np.arange(5) oa = OAS() assert_warns(UserWarning, oa.fit, X_1sample) assert_array_almost_equal(oa.covariance_, np.zeros(shape=(5, 5), dtype=np.float64)) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X) assert_almost_equal(oa.score(X), score_, 4) assert (oa.precision_ is None)
def test_oas(): """Tests OAS module on a simple dataset. """ # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) oa = OAS(assume_centered=True) oa.fit(X_centered) shrinkage_ = oa.shrinkage_ score_ = oa.score(X_centered) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_centered, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS(assume_centered=True) oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal((X_1d**2).sum() / n_samples, oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False, assume_centered=True) oa.fit(X_centered) assert_almost_equal(oa.score(X_centered), score_, 4) assert (oa.precision_ is None) ### Same tests without assuming centered data # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X) assert_almost_equal(oa.shrinkage_, shrinkage_, 4) assert_almost_equal(oa.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS() oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4) # test with one sample X_1sample = np.arange(5) oa = OAS() with warnings.catch_warnings(record=True): oa.fit(X_1sample) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X) assert_almost_equal(oa.score(X), score_, 4) assert (oa.precision_ is None)
def test_ledoit_wolf(): """Tests LedoitWolf module on a simple dataset. """ # test shrinkage coeff on a simple data set lw = LedoitWolf() lw.fit(X, assume_centered=True) assert_almost_equal(lw.shrinkage_, 0.00192, 4) assert_almost_equal(lw.score(X, assume_centered=True), -2.89795, 4) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_) scov.fit(X, assume_centered=True) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf() lw.fit(X_1d, assume_centered=True) lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_1d, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) assert_array_almost_equal((X_1d ** 2).sum() / n_samples, lw.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False) lw.fit(X, assume_centered=True) assert_almost_equal(lw.score(X, assume_centered=True), -2.89795, 4) assert(lw.precision_ is None) # Same tests without assuming centered data # test shrinkage coeff on a simple data set lw = LedoitWolf() lw.fit(X) assert_almost_equal(lw.shrinkage_, 0.007582, 4) assert_almost_equal(lw.score(X), 2.243483, 4) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf() lw.fit(X_1d) lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_1d) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), lw.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False) lw.fit(X) assert_almost_equal(lw.score(X), 2.2434839, 4) assert(lw.precision_ is None)
def fit(self, epochs_data, y): """Estimate the CSP decomposition on epochs. Parameters ---------- epochs_data : array, shape=(n_epochs, n_channels, n_times) The data to estimate the CSP on. y : array The class for each epoch. Returns ------- self : instance of CSP Returns the modified instance. """ if not isinstance(epochs_data, np.ndarray): raise ValueError("epochs_data should be of type ndarray (got %s)." % type(epochs_data)) epochs_data = np.atleast_3d(epochs_data) classes = np.unique(y) if len(classes) != 2: raise ValueError("More than two different classes in the data.") # concatenate epochs class_1 = np.transpose(epochs_data[y == classes[0]], [1, 0, 2]).reshape(epochs_data.shape[1], -1) class_2 = np.transpose(epochs_data[y == classes[1]], [1, 0, 2]).reshape(epochs_data.shape[1], -1) if self.reg is None: # compute empirical covariance cov_1 = np.dot(class_1, class_1.T) cov_2 = np.dot(class_2, class_2.T) else: # use sklearn covariance estimators if isinstance(self.reg, float): if (self.reg < 0) or (self.reg > 1): raise ValueError('0 <= shrinkage <= 1 for ' 'covariance regularization.') try: import sklearn sklearn_version = LooseVersion(sklearn.__version__) from sklearn.covariance import ShrunkCovariance except ImportError: raise Exception('the scikit-learn package is missing and ' 'required for covariance regularization.') if sklearn_version < '0.12': skl_cov = ShrunkCovariance(shrinkage=self.reg, store_precision=False) else: # init sklearn.covariance.ShrunkCovariance estimator skl_cov = ShrunkCovariance(shrinkage=self.reg, store_precision=False, assume_centered=True) elif isinstance(self.reg, str): if self.reg == 'lws': try: from sklearn.covariance import LedoitWolf except ImportError: raise Exception('the scikit-learn package is missing ' 'and required for regularization.') # init sklearn.covariance.LedoitWolf estimator skl_cov = LedoitWolf(store_precision=False, assume_centered=True) elif self.reg == 'oas': try: from sklearn.covariance import OAS except ImportError: raise Exception('the scikit-learn package is missing ' 'and required for regularization.') # init sklearn.covariance.OAS estimator skl_cov = OAS(store_precision=False, assume_centered=True) else: raise ValueError("regularization parameter should be " "of type str (got %s)." % type(self.reg)) else: raise ValueError("regularization parameter should be " "of type str (got %s)." % type(self.reg)) # compute regularized covariance using sklearn cov_1 = skl_cov.fit(class_1.T).covariance_ cov_2 = skl_cov.fit(class_2.T).covariance_ # then fit on covariance self._fit(cov_1, cov_2) pick_filters = self.filters_[:self.n_components] X = np.asarray([np.dot(pick_filters, e) for e in epochs_data]) # compute features (mean band power) X = (X ** 2).mean(axis=-1) # To standardize features self.mean_ = X.mean(axis=0) self.std_ = X.std(axis=0) return self
def test_ledoit_wolf(): """Tests LedoitWolf module on a simple dataset. """ # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) lw = LedoitWolf(assume_centered=True) lw.fit(X_centered) shrinkage_ = lw.shrinkage_ score_ = lw.score(X_centered) assert_almost_equal(ledoit_wolf_shrinkage(X_centered, assume_centered=True), shrinkage_) assert_almost_equal(ledoit_wolf_shrinkage(X_centered, assume_centered=True, block_size=6), shrinkage_) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_centered, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf(assume_centered=True) lw.fit(X_1d) lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_1d, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) assert_array_almost_equal((X_1d ** 2).sum() / n_samples, lw.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False, assume_centered=True) lw.fit(X_centered) assert_almost_equal(lw.score(X_centered), score_, 4) assert(lw.precision_ is None) # (too) large data set X_large = np.ones((20, 200)) assert_raises(MemoryError, ledoit_wolf, X_large, block_size=100) # Same tests without assuming centered data # test shrinkage coeff on a simple data set lw = LedoitWolf() lw.fit(X) assert_almost_equal(lw.shrinkage_, shrinkage_, 4) assert_almost_equal(lw.shrinkage_, ledoit_wolf_shrinkage(X)) assert_almost_equal(lw.shrinkage_, ledoit_wolf(X)[1]) assert_almost_equal(lw.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf() lw.fit(X_1d) lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_1d) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), lw.covariance_, 4) # test with one sample X_1sample = np.arange(5) lw = LedoitWolf() with warnings.catch_warnings(record=True): lw.fit(X_1sample) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False) lw.fit(X) assert_almost_equal(lw.score(X), score_, 4) assert(lw.precision_ is None)
def calShrunkCov(weekly_return): '''calculate Shrunk Covariance. ie. a 10 asset return array should return 10 * 10 dimension array Input: N * K np.array . Output: N * N array''' return ShrunkCovariance(0.1).fit(weekly_return.dropna().values).covariance_
def test_oas(): """Tests OAS module on a simple dataset. """ # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X, assume_centered=True) assert_almost_equal(oa.shrinkage_, 0.018740, 4) assert_almost_equal(oa.score(X, assume_centered=True), -5.03605, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X, assume_centered=True) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS() oa.fit(X_1d, assume_centered=True) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal((X_1d ** 2).sum() / n_samples, oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X, assume_centered=True) assert_almost_equal(oa.score(X, assume_centered=True), -5.03605, 4) assert(oa.precision_ is None) ### Same tests without assuming centered data # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X) assert_almost_equal(oa.shrinkage_, 0.020236, 4) assert_almost_equal(oa.score(X), 2.079025, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS() oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X) assert_almost_equal(oa.score(X), 2.079025, 4) assert(oa.precision_ is None)
def fit(self, epochs_data, y): """Estimate the CSP decomposition on epochs. Parameters ---------- epochs_data : array, shape=(n_epochs, n_channels, n_times) The data to estimate the CSP on. y : array The class for each epoch. Returns ------- self : instance of CSP Returns the modified instance. """ if not isinstance(epochs_data, np.ndarray): raise ValueError( "epochs_data should be of type ndarray (got %s)." % type(epochs_data)) epochs_data = np.atleast_3d(epochs_data) classes = np.unique(y) if len(classes) != 2: raise ValueError("More than two different classes in the data.") # concatenate epochs class_1 = np.transpose(epochs_data[y == classes[0]], [1, 0, 2]).reshape(epochs_data.shape[1], -1) class_2 = np.transpose(epochs_data[y == classes[1]], [1, 0, 2]).reshape(epochs_data.shape[1], -1) if self.reg is None: # compute empirical covariance cov_1 = np.dot(class_1, class_1.T) cov_2 = np.dot(class_2, class_2.T) else: # use sklearn covariance estimators if isinstance(self.reg, float): if (self.reg < 0) or (self.reg > 1): raise ValueError('0 <= shrinkage <= 1 for ' 'covariance regularization.') try: import sklearn sklearn_version = LooseVersion(sklearn.__version__) from sklearn.covariance import ShrunkCovariance except ImportError: raise Exception('the scikit-learn package is missing and ' 'required for covariance regularization.') if sklearn_version < '0.12': skl_cov = ShrunkCovariance(shrinkage=self.reg, store_precision=False) else: # init sklearn.covariance.ShrunkCovariance estimator skl_cov = ShrunkCovariance(shrinkage=self.reg, store_precision=False, assume_centered=True) elif isinstance(self.reg, str): if self.reg == 'lws': try: from sklearn.covariance import LedoitWolf except ImportError: raise Exception('the scikit-learn package is missing ' 'and required for regularization.') # init sklearn.covariance.LedoitWolf estimator skl_cov = LedoitWolf(store_precision=False, assume_centered=True) elif self.reg == 'oas': try: from sklearn.covariance import OAS except ImportError: raise Exception('the scikit-learn package is missing ' 'and required for regularization.') # init sklearn.covariance.OAS estimator skl_cov = OAS(store_precision=False, assume_centered=True) else: raise ValueError("regularization parameter should be " "of type str (got %s)." % type(self.reg)) else: raise ValueError("regularization parameter should be " "of type str (got %s)." % type(self.reg)) # compute regularized covariance using sklearn cov_1 = skl_cov.fit(class_1.T).covariance_ cov_2 = skl_cov.fit(class_2.T).covariance_ # then fit on covariance self._fit(cov_1, cov_2) pick_filters = self.filters_[:self.n_components] X = np.asarray([np.dot(pick_filters, e) for e in epochs_data]) # compute features (mean band power) X = (X**2).mean(axis=-1) # To standardize features self.mean_ = X.mean(axis=0) self.std_ = X.std(axis=0) return self
def test_oas(): # Tests OAS module on a simple dataset. # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) oa = OAS(assume_centered=True) oa.fit(X_centered) shrinkage_ = oa.shrinkage_ score_ = oa.score(X_centered) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_centered, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0:1] oa = OAS(assume_centered=True) oa.fit(X_1d) oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_1d, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) assert_array_almost_equal((X_1d ** 2).sum() / n_samples, oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False, assume_centered=True) oa.fit(X_centered) assert_almost_equal(oa.score(X_centered), score_, 4) assert(oa.precision_ is None) # Same tests without assuming centered data-------------------------------- # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X) assert_almost_equal(oa.shrinkage_, shrinkage_, 4) assert_almost_equal(oa.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shrinkage_from_mle = oas(X) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS() oa.fit(X_1d) oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_1d) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4) # test with one sample # warning should be raised when using only 1 sample X_1sample = np.arange(5).reshape(1, 5) oa = OAS() assert_warns(UserWarning, oa.fit, X_1sample) assert_array_almost_equal(oa.covariance_, np.zeros(shape=(5, 5), dtype=np.float64)) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X) assert_almost_equal(oa.score(X), score_, 4) assert(oa.precision_ is None)
def shrunk_cov_score(x): shrinkages = np.logspace(-2, 0, 30) #-2~0之间取30个值 cv = GridSearchCV(ShrunkCovariance(), {'shrinkage': shrinkages}) #网格搜索最优参数 return np.mean(cross_val_score(cv.fit(x).best_estimator_, x))
def test_ledoit_wolf(): # Tests LedoitWolf module on a simple dataset. # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) lw = LedoitWolf(assume_centered=True) lw.fit(X_centered) shrinkage_ = lw.shrinkage_ score_ = lw.score(X_centered) assert_almost_equal( ledoit_wolf_shrinkage(X_centered, assume_centered=True), shrinkage_) assert_almost_equal( ledoit_wolf_shrinkage(X_centered, assume_centered=True, block_size=6), shrinkage_) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_centered, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf(assume_centered=True) lw.fit(X_1d) lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_1d, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) assert_array_almost_equal((X_1d**2).sum() / n_samples, lw.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False, assume_centered=True) lw.fit(X_centered) assert_almost_equal(lw.score(X_centered), score_, 4) assert (lw.precision_ is None) # Same tests without assuming centered data # test shrinkage coeff on a simple data set lw = LedoitWolf() lw.fit(X) assert_almost_equal(lw.shrinkage_, shrinkage_, 4) assert_almost_equal(lw.shrinkage_, ledoit_wolf_shrinkage(X)) assert_almost_equal(lw.shrinkage_, ledoit_wolf(X)[1]) assert_almost_equal(lw.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf() lw.fit(X_1d) lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_1d) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), lw.covariance_, 4) # test with one sample # warning should be raised when using only 1 sample X_1sample = np.arange(5).reshape(1, 5) lw = LedoitWolf() warn_msg = ( "Only one sample available. You may want to reshape your data array") with pytest.warns(UserWarning, match=warn_msg): lw.fit(X_1sample) assert_array_almost_equal(lw.covariance_, np.zeros(shape=(5, 5), dtype=np.float64)) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False) lw.fit(X) assert_almost_equal(lw.score(X), score_, 4) assert (lw.precision_ is None)
n_features, n_samples = 40, 20 np.random.seed(42) base_X_train = np.random.normal(size=(n_samples, n_features)) base_X_test = np.random.normal(size=(n_samples, n_features)) # Color samples coloring_matrix = np.random.normal(size=(n_features, n_features)) X_train = np.dot(base_X_train, coloring_matrix) X_test = np.dot(base_X_test, coloring_matrix) # ############################################################################# # Compute the likelihood on test data # spanning a range of possible shrinkage coefficient values shrinkages = np.logspace(-2, 0, 30) negative_logliks = [-ShrunkCovariance(shrinkage=s).fit(X_train).score(X_test) for s in shrinkages] # under the ground-truth model, which we would not have access to in real # settings real_cov = np.dot(coloring_matrix.T, coloring_matrix) emp_cov = empirical_covariance(X_train) loglik_real = -log_likelihood(emp_cov, linalg.inv(real_cov)) # ############################################################################# # Compare different approaches to setting the parameter # GridSearch for an optimal shrinkage coefficient tuned_parameters = [{'shrinkage': shrinkages}] cv = GridSearchCV(ShrunkCovariance(), tuned_parameters, cv=5) cv.fit(X_train)
def test_oas(): # Tests OAS module on a simple dataset. # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) oa = OAS(assume_centered=True) oa.fit(X_centered) shrinkage_ = oa.shrinkage_ score_ = oa.score(X_centered) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_centered, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0:1] oa = OAS(assume_centered=True) oa.fit(X_1d) oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_1d, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) assert_array_almost_equal((X_1d**2).sum() / n_samples, oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False, assume_centered=True) oa.fit(X_centered) assert_almost_equal(oa.score(X_centered), score_, 4) assert (oa.precision_ is None) # Same tests without assuming centered data-------------------------------- # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X) assert_almost_equal(oa.shrinkage_, shrinkage_, 4) assert_almost_equal(oa.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shrinkage_from_mle = oas(X) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS() oa.fit(X_1d) oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_1d) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4) # test with one sample # warning should be raised when using only 1 sample X_1sample = np.arange(5).reshape(1, 5) oa = OAS() warn_msg = ( "Only one sample available. You may want to reshape your data array") with pytest.warns(UserWarning, match=warn_msg): oa.fit(X_1sample) assert_array_almost_equal(oa.covariance_, np.zeros(shape=(5, 5), dtype=np.float64)) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X) assert_almost_equal(oa.score(X), score_, 4) assert (oa.precision_ is None)
def test_oas(): """Tests OAS module on a simple dataset. """ # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) oa = OAS(assume_centered=True) oa.fit(X_centered) shrinkage_ = oa.shrinkage_ score_ = oa.score(X_centered) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_centered, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS(assume_centered=True) oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d, assume_centered=True) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal((X_1d ** 2).sum() / n_samples, oa.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False, assume_centered=True) oa.fit(X_centered) assert_almost_equal(oa.score(X_centered), score_, 4) assert(oa.precision_ is None) ### Same tests without assuming centered data # test shrinkage coeff on a simple data set oa = OAS() oa.fit(X) assert_almost_equal(oa.shrinkage_, shrinkage_, 4) assert_almost_equal(oa.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate oa_cov_from_mle, oa_shinkrage_from_mle = oas(X) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) # compare estimates given by OAS and ShrunkCovariance scov = ShrunkCovariance(shrinkage=oa.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, oa.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) oa = OAS() oa.fit(X_1d) oa_cov_from_mle, oa_shinkrage_from_mle = oas(X_1d) assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4) assert_almost_equal(oa_shinkrage_from_mle, oa.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4) # test with one sample X_1sample = np.arange(5) oa = OAS() with warnings.catch_warnings(record=True): oa.fit(X_1sample) # test shrinkage coeff on a simple data set (without saving precision) oa = OAS(store_precision=False) oa.fit(X) assert_almost_equal(oa.score(X), score_, 4) assert(oa.precision_ is None)
def __init__(self, cov=ShrunkCovariance(shrinkage=0)): self.cov = cov self.mean = None
def test_shrunk_covariance(): """Tests ShrunkCovariance module on a simple dataset. """ # compare shrunk covariance obtained from data and from MLE estimate cov = ShrunkCovariance(shrinkage=0.5) cov.fit(X) assert_array_almost_equal( shrunk_covariance(empirical_covariance(X), shrinkage=0.5), cov.covariance_, 4) # same test with shrinkage not provided cov = ShrunkCovariance() cov.fit(X) assert_array_almost_equal( shrunk_covariance(empirical_covariance(X)), cov.covariance_, 4) # same test with shrinkage = 0 (<==> empirical_covariance) cov = ShrunkCovariance(shrinkage=0.) cov.fit(X) assert_array_almost_equal(empirical_covariance(X), cov.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) cov = ShrunkCovariance(shrinkage=0.3) cov.fit(X_1d) assert_array_almost_equal(empirical_covariance(X_1d), cov.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) cov = ShrunkCovariance(shrinkage=0.5, store_precision=False) cov.fit(X) assert(cov.precision_ is None)
def ll_visualizer_conv(safe, target): vs = log_likihood_visualizer(cov=conv_estimator( ShrunkCovariance(shrinkage=0)), min_difference=200) vs.fit(safe) vs.plot(target, title="Safe Dataset Likelihood")
class SpatialBeamformer(SpatialFilter): ''' LCMV Spatial beamformer. Parameters ---------- template : 1D array (n_channels) Spatial activation pattern of the component to extract. shrinkage : str | float (default: 'oas') Shrinkage parameter for the covariance matrix inversion. This can either be speficied as a number between 0 and 1, or as a string indicating which automated estimation method to use: 'none': No shrinkage: emperical covariance 'oas': Oracle approximation shrinkage 'lw': Ledoit-Wolf approximation shrinkage center : bool (default: True) Whether to remove the channel mean before applying the filter. ''' def __init__(self, template, shrinkage='oas', center=True): SpatialFilter.__init__(self, 1) self.template = template self.template = np.asarray(template).flatten()[:, np.newaxis] self.center = center if center: self.template -= self.template.mean() if shrinkage == 'oas': self.cov = OAS elif shrinkage == 'lw': self.cov = LedoitWolf elif shrinkage == 'none': self.cov = EmpiricalCovariance elif type(shrinkage) == float or type(shrinkage) == int: self.cov = ShrunkCovariance(shrinkage=shrinkage) def train_(self, d): if self.center: d = DataSet(d.data - d.data.mean(axis=0), default=d) d = baseline(d) # Calculate spatial covariance matrix c = self.cov.fit(concatenate_trials(d).X) sigma_x_i = c.precision_ # Compute spatial LCMV filter self.W = sigma_x_i.dot(self.template) # Noise normalization self.W = self.W.dot( np.linalg.inv( reduce(np.dot, [self.template.T, sigma_x_i, self.template]) ) ) def apply_(self, d): if self.center: d = DataSet(d.data - d.data.mean(axis=0), default=d) d = baseline(d) return SpatialFilter.apply_(self, d)
class LCMV(BaseEstimator, TransformerMixin): ''' LCMV Spatial beamformer. Parameters ---------- template : 1D array (n_channels) Spatial activation pattern of the component to extract. shrinkage : str | float (default: 'oas') Shrinkage parameter for the covariance matrix inversion. This can either be speficied as a number between 0 and 1, or as a string indicating which automated estimation method to use: 'none': No shrinkage: emperical covariance 'oas': Oracle approximation shrinkage 'lw': Ledoit-Wolf approximation shrinkage center : bool (default: True) Whether to remove the channel mean before applying the filter. Attributes ---------- W_ : 2D array (1 x n_channels) Row vector containing the filter weights. ''' def __init__(self, template, shrinkage='oas', center=True): self.template = template self.template = np.asarray(template).flatten()[:, np.newaxis] self.center = center if center: self.template -= self.template.mean() if shrinkage == 'oas': self.cov = OAS elif shrinkage == 'lw': self.cov = LedoitWolf elif shrinkage == 'none': self.cov = EmpiricalCovariance elif type(shrinkage) == float or type(shrinkage) == int: self.cov = ShrunkCovariance(shrinkage=shrinkage) def fit(self, X, y=None): """Fit the beamformer to the data. Parameters ---------- X : 3D array (n_channels, n_samples, n_trials) The trials. y : None Unused. """ if self.center: X = X - X.mean(axis=0) # Concatenate trials cont_eeg = np.transpose(X, [0, 2, 1]).reshape((X.shape[0], -1)) # Calculate spatial covariance matrix c = self.cov.fit(cont_eeg.T) sigma_x_i = c.precision_ # Compute spatial LCMV filter self.W_ = sigma_x_i.dot(self.template) # Noise normalization self.W_ = self.W_.dot( np.linalg.inv( reduce(np.dot, [self.template.T, sigma_x_i, self.template]) ) ) return self def transform(self, X): """Transform the data using the beamformer. Parameters ---------- X : 3D array (n_channels, n_samples, n_trials) The trials. Returns ------- X_trans : 3D array (1, n_samples, n_trials) The transformed data. """ if self.center: X = X - X.mean(axis=0) n_channels = self.W_.shape[1] n_samples = X.shape[1] n_trials = X.shape[2] X_trans = np.zeros((n_channels, n_samples, n_trials)) for i in range(n_trials): X_trans[:, :, i] = np.dot(self.W_.T, X[:, :, i]) return X_trans
def test_ledoit_wolf(): # Tests LedoitWolf module on a simple dataset. # test shrinkage coeff on a simple data set X_centered = X - X.mean(axis=0) lw = LedoitWolf(assume_centered=True) lw.fit(X_centered) shrinkage_ = lw.shrinkage_ score_ = lw.score(X_centered) assert_almost_equal( ledoit_wolf_shrinkage(X_centered, assume_centered=True), shrinkage_) assert_almost_equal( ledoit_wolf_shrinkage(X_centered, assume_centered=True, block_size=6), shrinkage_) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_centered, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_, assume_centered=True) scov.fit(X_centered) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf(assume_centered=True) lw.fit(X_1d) lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_1d, assume_centered=True) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) assert_array_almost_equal((X_1d**2).sum() / n_samples, lw.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False, assume_centered=True) lw.fit(X_centered) assert_almost_equal(lw.score(X_centered), score_, 4) assert (lw.precision_ is None) # (too) large data set X_large = np.ones((20, 200)) assert_raises(MemoryError, ledoit_wolf, X_large, block_size=100) # Same tests without assuming centered data # test shrinkage coeff on a simple data set lw = LedoitWolf() lw.fit(X) assert_almost_equal(lw.shrinkage_, shrinkage_, 4) assert_almost_equal(lw.shrinkage_, ledoit_wolf_shrinkage(X)) assert_almost_equal(lw.shrinkage_, ledoit_wolf(X)[1]) assert_almost_equal(lw.score(X), score_, 4) # compare shrunk covariance obtained from data and from MLE estimate lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) # compare estimates given by LW and ShrunkCovariance scov = ShrunkCovariance(shrinkage=lw.shrinkage_) scov.fit(X) assert_array_almost_equal(scov.covariance_, lw.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) lw = LedoitWolf() lw.fit(X_1d) lw_cov_from_mle, lw_shinkrage_from_mle = ledoit_wolf(X_1d) assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4) assert_almost_equal(lw_shinkrage_from_mle, lw.shrinkage_) assert_array_almost_equal(empirical_covariance(X_1d), lw.covariance_, 4) # test with one sample # FIXME I don't know what this test does X_1sample = np.arange(5) lw = LedoitWolf() assert_warns(UserWarning, lw.fit, X_1sample) assert_array_almost_equal(lw.covariance_, np.zeros(shape=(5, 5), dtype=np.float64)) # test shrinkage coeff on a simple data set (without saving precision) lw = LedoitWolf(store_precision=False) lw.fit(X) assert_almost_equal(lw.score(X), score_, 4) assert (lw.precision_ is None)
def import_mat_func(input_file, ID, atlas_select, NETWORK, pynets_dir, node_size, mask, thr, graph, parlistfile, sps_model): if '.nii' in input_file and parlistfile == None and NETWORK == None: if graph == False: func_file = input_file dir_path = os.path.dirname(os.path.realpath(func_file)) atlas = getattr(datasets, 'fetch_%s' % atlas_select)() atlas_name = atlas['description'].splitlines()[0] print(atlas_name + ' comes with {0}.'.format(atlas.keys())) print("\n") coords = np.vstack( (atlas.rois['x'], atlas.rois['y'], atlas.rois['z'])).T print('Stacked atlas coordinates in array of shape {0}.'.format( coords.shape)) print("\n") if mask is not None: from nilearn import masking mask_data, _ = masking._load_mask_img(mask) mask_coords = list(zip(*np.where(mask_data != 0))) for coord in coords: if tuple(coord) not in mask_coords: print('Removing coordinate: ' + str(tuple(coord)) + ' since it falls outside of network mask...') ix = np.where(coords == coord)[0][0] coords = np.delete(coords, ix, axis=0) print(str(len(coords))) print("\n") spheres_masker = input_data.NiftiSpheresMasker( seeds=coords, radius=float(node_size), memory='nilearn_cache', memory_level=5, verbose=2) time_series = spheres_masker.fit_transform(func_file) correlation_measure = ConnectivityMeasure(kind='correlation') correlation_matrix = correlation_measure.fit_transform( [time_series])[0] print("\n") print('Time series has {0} samples'.format(time_series.shape[0])) print("\n") else: correlation_matrix = genfromtxt(graph, delimiter='\t') plt.imshow(correlation_matrix, vmin=-1., vmax=1., cmap='RdBu_r', interpolation='nearest') plt.colorbar() plt.title(atlas_name + ' correlation matrix') out_path_fig = dir_path + '/' + ID + '_' + atlas_name + '_adj_mat_corr.png' plt.savefig(out_path_fig) plt.close() ##Tweak edge_threshold to keep only the strongest connections. atlast_graph_title = atlas_name + ' correlation graph' if mask is None: atlast_graph_title = atlas_name + ' correlation graph' else: atlast_graph_title = atlas_name + ' Masked Nodes' edge_threshold = str(float(thr) * 100) + '%' plotting.plot_connectome(correlation_matrix, coords, title=atlast_graph_title, edge_threshold=edge_threshold, node_size=20, colorbar=True) out_path_fig = dir_path + '/' + ID + '_' + atlas_name + '_connectome_viz.png' plt.savefig(out_path_fig) plt.close() time_series_path = dir_path + '/' + ID + '_ts.txt' np.savetxt(time_series_path, time_series, delimiter='\t') mx = genfromtxt(time_series_path, delimiter='') elif '.nii' in input_file and parlistfile != None and NETWORK == None: # block of code for whole brain parcellations func_file = input_file dir_path = os.path.dirname(os.path.realpath(func_file)) atlas_name = parlistfile.split('/')[-1].split('.')[0] # Code for getting name and coordinates of parcels. # Adapted from Dan L. (https://github.com/danlurie/despolab_lesion/blob/master/code/sandbox/Sandbox%20-%20Calculate%20and%20plot%20HCP%20mean%20matrix.ipynb) bna_img = nib.load(parlistfile) bna_data = bna_img.get_data() if bna_img.get_data_dtype() != np.dtype(np.int): bna_data_for_coords = bna_img.get_data() # Number of parcels: par_max = np.ceil(np.max(bna_data_for_coords)).astype('int') bna_data = bna_data.astype('int16') else: par_max = np.max(bna_data) img_stack = [] for idx in range(1, par_max + 1): roi_img = bna_data == idx img_stack.append(roi_img) img_stack = np.array(img_stack) img_list = [] for idx in range(par_max): roi_img = nilearn.image.new_img_like(bna_img, img_stack[idx]) img_list.append(roi_img) bna_4D = nilearn.image.concat_imgs(img_list) coords = [] for roi_img in img_list: coords.append(nilearn.plotting.find_xyz_cut_coords(roi_img)) coords = np.array(coords) # atlas = getattr(datasets, 'fetch_%s' % atlas_select)() # atlas_name = atlas['description'].splitlines()[0] print("\n") print(atlas_name + ' comes with {0}.'.format(par_max) + 'parcels') print("\n") print("\n") print('Stacked atlas coordinates in array of shape {0}.'.format( coords.shape)) print("\n") if mask is not None: from nilearn import masking mask_data, _ = masking._load_mask_img(mask) mask_coords = list(zip(*np.where(mask_data != 0))) for coord in coords: if tuple(coord) not in mask_coords: print('Removing coordinate: ' + str(tuple(coord)) + ' since it falls outside of network mask...') ix = np.where(coords == coord)[0][0] coords = np.delete(coords, ix, axis=0) print(str(len(coords))) ##extract time series from whole brain parcellaions: parcellation = nib.load(parlistfile) parcel_masker = input_data.NiftiLabelsMasker(labels_img=parcellation, background_label=0, memory='nilearn_cache', memory_level=5) time_series = parcel_masker.fit_transform(func_file) ##old ref code for coordinate parcellations: #spheres_masker = input_data.NiftiSpheresMasker(seeds=coords, radius=float(node_size), memory='nilearn_cache', memory_level=2, verbose=2) #time_series = spheres_masker.fit_transform(func_file) correlation_measure = ConnectivityMeasure(kind='correlation') correlation_matrix = correlation_measure.fit_transform([time_series ])[0] print("\n") print('Time series has {0} samples'.format(time_series.shape[0])) print("\n") plt.imshow(correlation_matrix, vmin=-1., vmax=1., cmap='RdBu_r', interpolation='nearest') plt.colorbar() plt.title(atlas_name + ' correlation matrix') out_path_fig = dir_path + '/' + ID + '_' + atlas_name + '_adj_mat_corr.png' plt.savefig(out_path_fig) plt.close() ##Tweak edge_threshold to keep only the strongest connections. atlast_graph_title = atlas_name + ' correlation graph' if mask is None: atlast_graph_title = atlas_name + ' correlation graph' else: atlast_graph_title = atlas_name + ' Masked Nodes' edge_threshold = str(float(thr) * 100) + '%' plotting.plot_connectome(correlation_matrix, coords, title=atlast_graph_title, edge_threshold=edge_threshold, node_size=20, colorbar=True) out_path_fig = dir_path + '/' + ID + '_' + atlas_name + '_connectome_viz.png' plt.savefig(out_path_fig) plt.close() time_series_path = dir_path + '/' + ID + '_ts.txt' np.savetxt(time_series_path, time_series, delimiter='\t') mx = genfromtxt(time_series_path, delimiter='') elif '.nii' in input_file and NETWORK != None: func_file = input_file ##Reference RSN list load_path = pynets_dir + '/RSN_refs/' + NETWORK + '_coords.csv' df = pd.read_csv(load_path).ix[:, 0:4] i = 1 coords = [] labels = [] for i in range(len(df)): print("ROI Reference #: " + str(i)) x = int(df.ix[i, 1]) y = int(df.ix[i, 2]) z = int(df.ix[i, 3]) print("X:" + str(x) + " Y:" + str(y) + " Z:" + str(z)) coords.append((x, y, z)) labels.append(i) print("\n") print(coords) print(labels) print("\n") print("-------------------") i + 1 dir_path = os.path.dirname(os.path.realpath(func_file)) ##Grow ROIs ##If masking, remove those coords that fall outside of the mask if mask != None: from nilearn import masking mask_data, _ = masking._load_mask_img(mask) mask_coords = list(zip(*np.where(mask_data != 0))) for coord in coords: if coord in mask_coords: print('Removing coordinate: ' + str(coord) + ' since it falls outside of network mask...') coords.remove(coord) masker = input_data.NiftiSpheresMasker(seeds=coords, radius=float(node_size), allow_overlap=True, memory_level=5, memory='nilearn_cache', verbose=2) time_series = masker.fit_transform(func_file) for time_serie, label in zip(time_series.T, labels): plt.plot(time_serie, label=label) plt.title(NETWORK + ' Network Time Series') plt.xlabel('Scan Number') plt.ylabel('Normalized Signal') plt.legend() plt.tight_layout() out_path_fig = dir_path + '/' + ID + '_' + NETWORK + '_TS_plot.png' plt.savefig(out_path_fig) plt.close() connectivity_measure = ConnectivityMeasure(kind='correlation') correlation_matrix = connectivity_measure.fit_transform([time_series ])[0] plot_title = NETWORK + ' Network Time Series' plotting.plot_connectome(correlation_matrix, coords, title=plot_title) ##Display connectome with hemispheric projections. title = "Connectivity Projected on the " + NETWORK out_path_fig = dir_path + '/' + ID + '_' + NETWORK + '_connectome_plot.png' plotting.plot_connectome(correlation_matrix, coords, title=title, display_mode='lyrz', output_file=out_path_fig) time_series_path = dir_path + '/' + ID + '_' + NETWORK + '_ts.txt' np.savetxt(time_series_path, time_series, delimiter='\t') mx = genfromtxt(time_series_path, delimiter='') else: DR_st_1 = input_file dir_path = os.path.dirname(os.path.realpath(DR_st_1)) mx = genfromtxt(DR_st_1, delimiter='') from sklearn.covariance import GraphLassoCV, ShrunkCovariance, graph_lasso estimator = GraphLassoCV() try: est = estimator.fit(mx) except: # print("WARNING: Lasso Cross-Validation Failed. Using Shrunk Covariance instead...") # emp_cov = covariance.empirical_covariance(mx) # shrunk_cov = covariance.shrunk_covariance(emp_cov, shrinkage=0.8) # Set shrinkage closer to 1 for poorly-conditioned data # # alphaRange = 10.0 ** np.arange(-8,0) # 1e-7 to 1e-1 by order of magnitude # for alpha in alphaRange: # try: # estimator = covariance.graph_lasso(shrunk_cov, alpha) # print("Calculated graph-lasso covariance matrix for alpha=%s"%alpha) # except FloatingPointError: # print("Failed at alpha=%s"%alpha) estimator = ShrunkCovariance() est = estimator.fit(mx) if NETWORK != None: est_path = dir_path + '/' + ID + '_' + NETWORK + '_est%s.txt' % ( '_sps_inv' if sps_model else '') else: est_path = dir_path + '/' + ID + '_est_%s.txt' % ('_sps_inv' if sps_model else '') if sps_model == False: if NETWORK != None: np.savetxt(est_path, correlation_matrix, delimiter='\t') else: np.savetxt(est_path, correlation_matrix, delimiter='\t') elif sps_model == True: np.savetxt(est_path, estimator.precision_, delimiter='\t') return (mx, est_path)
def test_shrunk_covariance(): # Tests ShrunkCovariance module on a simple dataset. # compare shrunk covariance obtained from data and from MLE estimate cov = ShrunkCovariance(shrinkage=0.5) cov.fit(X) assert_array_almost_equal( shrunk_covariance(empirical_covariance(X), shrinkage=0.5), cov.covariance_, 4) # same test with shrinkage not provided cov = ShrunkCovariance() cov.fit(X) assert_array_almost_equal(shrunk_covariance(empirical_covariance(X)), cov.covariance_, 4) # same test with shrinkage = 0 (<==> empirical_covariance) cov = ShrunkCovariance(shrinkage=0.) cov.fit(X) assert_array_almost_equal(empirical_covariance(X), cov.covariance_, 4) # test with n_features = 1 X_1d = X[:, 0].reshape((-1, 1)) cov = ShrunkCovariance(shrinkage=0.3) cov.fit(X_1d) assert_array_almost_equal(empirical_covariance(X_1d), cov.covariance_, 4) # test shrinkage coeff on a simple data set (without saving precision) cov = ShrunkCovariance(shrinkage=0.5, store_precision=False) cov.fit(X) assert (cov.precision_ is None)
# Compute Ledoit-Wolf and Covariances on a grid of shrinkages from sklearn.covariance import LedoitWolf, OAS, ShrunkCovariance, \ log_likelihood, empirical_covariance # Ledoit-Wolf optimal shrinkage coefficient estimate lw = LedoitWolf() loglik_lw = lw.fit(X_train).score(X_test) # OAS coefficient estimate oa = OAS() loglik_oa = oa.fit(X_train).score(X_test) # spanning a range of possible shrinkage coefficient values shrinkages = np.logspace(-3, 0, 30) negative_logliks = [-ShrunkCovariance(shrinkage=s).fit(X_train).score(X_test) for s in shrinkages] # getting the likelihood under the real model real_cov = np.dot(coloring_matrix.T, coloring_matrix) emp_cov = empirical_covariance(X_train) loglik_real = -log_likelihood(emp_cov, linalg.inv(real_cov)) ############################################################################### # Plot results pl.figure() pl.title("Regularized covariance: likelihood and shrinkage coefficient") pl.xlabel('Shrinkage') pl.ylabel('Negative log-likelihood') # range shrinkage curve pl.loglog(shrinkages, negative_logliks)
def shrunk_cov_score(X): shrinkages = np.logspace(-2, 0, 30) cv = GridSearchCV(ShrunkCovariance(), {'shrinkage': shrinkages}) return np.mean(cross_val_score(cv.fit(X).best_estimator_, X))
from sklearn.covariance import LedoitWolf, OAS, ShrunkCovariance, \ log_likelihood, empirical_covariance # Ledoit-Wolf optimal shrinkage coefficient estimate lw = LedoitWolf() loglik_lw = lw.fit(X_train, assume_centered=True).score( X_test, assume_centered=True) # OAS coefficient estimate oa = OAS() loglik_oa = oa.fit(X_train, assume_centered=True).score( X_test, assume_centered=True) # spanning a range of possible shrinkage coefficient values shrinkages = np.logspace(-3, 0, 30) negative_logliks = [-ShrunkCovariance(shrinkage=s).fit( X_train, assume_centered=True).score(X_test, assume_centered=True) \ for s in shrinkages] # getting the likelihood under the real model real_cov = np.dot(coloring_matrix.T, coloring_matrix) emp_cov = empirical_covariance(X_train) loglik_real = -log_likelihood(emp_cov, linalg.inv(real_cov)) ############################################################################### # Plot results pl.figure(-1) pl.title("Regularized covariance: likelihood and shrinkage coefficient") pl.xlabel('Shrinkage') pl.ylabel('Negative log-likelihood') # range shrinkage curve pl.loglog(shrinkages, negative_logliks)