def test_vec_to_sym_matrix():
# Check error if unsuitable size
vec = np.ones(31)
with pytest.raises(ValueError, match='Vector of unsuitable shape'):
vec_to_sym_matrix(vec)
# Check error if given diagonal shape incompatible with vec
vec = np.ones(3)
diagonal = np.zeros(4)
with pytest.raises(ValueError, match='incompatible with vector'):
vec_to_sym_matrix(vec, diagonal)
# Check output value is correct
vec = np.ones(6, )
sym = np.array([[sqrt(2), 1., 1.], [1., sqrt(2), 1.],
[1., 1., sqrt(2)]])
assert_array_almost_equal(vec_to_sym_matrix(vec), sym)
# Check output value is correct with seperate diagonal
vec = np.ones(3, )
diagonal = np.ones(3)
assert_array_almost_equal(vec_to_sym_matrix(vec, diagonal=diagonal), sym)
# Check vec_to_sym_matrix is the inverse function of sym_matrix_to_vec
# when diagonal is included
assert_array_almost_equal(vec_to_sym_matrix(sym_matrix_to_vec(sym)), sym)
# when diagonal is discarded
vec = sym_matrix_to_vec(sym, discard_diagonal=True)
diagonal = np.diagonal(sym) / sqrt(2)
assert_array_almost_equal(vec_to_sym_matrix(vec, diagonal=diagonal), sym)
def test_vec_to_sym_matrix():
# Check error if unsuitable size
vec = np.ones(31)
assert_raises_regex(ValueError, 'Vector of unsuitable shape',
vec_to_sym_matrix, vec)
# Check error if given diagonal shape incompatible with vec
vec = np.ones(3)
diagonal = np.zeros(4)
assert_raises_regex(ValueError, 'incompatible with vector',
vec_to_sym_matrix, vec, diagonal)
# Check output value is correct
vec = np.ones(6, )
sym = np.array([[sqrt(2), 1., 1.], [1., sqrt(2), 1.],
[1., 1., sqrt(2)]])
assert_array_almost_equal(vec_to_sym_matrix(vec), sym)
# Check output value is correct with seperate diagonal
vec = np.ones(3, )
diagonal = np.ones(3)
assert_array_almost_equal(vec_to_sym_matrix(vec, diagonal=diagonal), sym)
# Check vec_to_sym_matrix is the inverse function of sym_matrix_to_vec
# when diagonal is included
assert_array_almost_equal(vec_to_sym_matrix(sym_matrix_to_vec(sym)), sym)
# when diagonal is discarded
vec = sym_matrix_to_vec(sym, discard_diagonal=True)
diagonal = np.diagonal(sym) / sqrt(2)
assert_array_almost_equal(vec_to_sym_matrix(vec, diagonal=diagonal), sym)
def fit(self, X, y=None):
"""Fit PoSCE to the given time series for each subject
Parameters
----------
X : list of n_subjects numpy.ndarray, shapes (n_samples, n_features)
The input subjects time series. The number of samples may differ
from one subject to another
Returns
-------
self : PopulationShrunkCovariance instance
The object itself. Useful for chaining operations.
"""
# compute covariances from timeseries
self.cov_estimator_ = clone(self.cov_estimator)
covariances = [self.cov_estimator_.fit(x).covariance_ for x in X]
# compute prior mean
if self.prior_mean_type == "geometric":
self.prior_mean_ = _geometric_mean(covariances,
max_iter=30,
tol=1e-7)
elif self.prior_mean_type == "empirical":
self.prior_mean_ = np.mean(covariances, axis=0)
else:
raise ValueError("Allowed mean types are"
'"geometric", "euclidean"'
', got type "{}"'.format(self.prior_mean_type))
self.prior_whitening_ = _map_eigenvalues(lambda x: 1.0 / np.sqrt(x),
self.prior_mean_)
self.prior_whitening_inv_ = _map_eigenvalues(lambda x: np.sqrt(x),
self.prior_mean_)
# compute the population prior dispersion
connectivities = [
_map_eigenvalues(
np.log,
self.prior_whitening_.dot(cov).dot(self.prior_whitening_))
for cov in covariances
]
connectivities = np.array(connectivities)
connectivities = sym_matrix_to_vec(connectivities)
self.prior_cov_ = np.mean(
[
np.expand_dims(c, 1).dot(np.expand_dims(c, 0))
for c in connectivities
],
axis=0,
)
# approximate the population prior dispersion
self.prior_cov_approx_ = regularized_eigenvalue_decomposition(
self.prior_cov_, explained_variance_threshold=0.7)
return self
def test_sym_matrix_to_vec():
sym = np.ones((3, 3))
sqrt2 = 1. / sqrt(2.)
vec = np.array([sqrt2, 1., sqrt2, 1., 1., sqrt2])
assert_array_almost_equal(sym_matrix_to_vec(sym), vec)
vec = np.array([1., 1., 1.])
assert_array_almost_equal(sym_matrix_to_vec(sym, discard_diagonal=True),
vec)
# Check sym_matrix_to_vec is the inverse function of vec_to_sym_matrix
n = 5
p = n * (n + 1) // 2
rand_gen = np.random.RandomState(0)
# when diagonal is included
vec = rand_gen.rand(p)
sym = vec_to_sym_matrix(vec)
assert_array_almost_equal(sym_matrix_to_vec(sym), vec)
# when diagonal given separately
diagonal = rand_gen.rand(n + 1)
sym = vec_to_sym_matrix(vec, diagonal=diagonal)
assert_array_almost_equal(sym_matrix_to_vec(sym, discard_diagonal=True),
vec)
# multiple matrices case when diagonal is included
vecs = np.asarray([vec, 2. * vec, 0.5 * vec])
syms = vec_to_sym_matrix(vecs)
assert_array_almost_equal(sym_matrix_to_vec(syms), vecs)
# multiple matrices case when diagonal is given seperately
diagonals = np.asarray([diagonal, 3. * diagonal, -diagonal])
syms = vec_to_sym_matrix(vecs, diagonal=diagonals)
assert_array_almost_equal(sym_matrix_to_vec(syms, discard_diagonal=True),
vecs)
def test_sym_matrix_to_vec():
sym = np.ones((3, 3))
sqrt2 = 1. / sqrt(2.)
vec = np.array([sqrt2, 1., sqrt2, 1., 1., sqrt2])
assert_array_almost_equal(sym_matrix_to_vec(sym), vec)
vec = np.array([1., 1., 1.])
assert_array_almost_equal(sym_matrix_to_vec(sym, discard_diagonal=True),
vec)
# Check sym_matrix_to_vec is the inverse function of vec_to_sym_matrix
n = 5
p = n * (n + 1) // 2
rand_gen = np.random.RandomState(0)
# when diagonal is included
vec = rand_gen.rand(p)
sym = vec_to_sym_matrix(vec)
assert_array_almost_equal(sym_matrix_to_vec(sym), vec)
# when diagonal given separately
diagonal = rand_gen.rand(n + 1)
sym = vec_to_sym_matrix(vec, diagonal=diagonal)
assert_array_almost_equal(sym_matrix_to_vec(sym, discard_diagonal=True),
vec)
# multiple matrices case when diagonal is included
vecs = np.asarray([vec, 2. * vec, 0.5 * vec])
syms = vec_to_sym_matrix(vecs)
assert_array_almost_equal(sym_matrix_to_vec(syms), vecs)
# multiple matrices case when diagonal is given seperately
diagonals = np.asarray([diagonal, 3. * diagonal, -diagonal])
syms = vec_to_sym_matrix(vecs, diagonal=diagonals)
assert_array_almost_equal(sym_matrix_to_vec(syms, discard_diagonal=True),
vecs)
def transform(self, X):
"""Transform subjects timeseries to shrunk covariances in the tangent
space using the population prior.
Parameters
----------
X : list of n_subjects numpy.ndarray, shapes (n_samples, n_features)
The input subjects time series. The number of samples may differ
from one subject to another
Returns
-------
shrunk_connectivities : numpy.ndarray, shape
(n_subjects, n_features * (n_features + 1) / 2).
Shrunk individual connectivities as vectors.
"""
# compute covariances from timeseries
covariances = [self.cov_estimator_.fit(x).covariance_ for x in X]
# transform in the tangent space
connectivities = [
_map_eigenvalues(
np.log,
self.prior_whitening_.dot(cov).dot(self.prior_whitening_))
for cov in covariances
]
connectivities = np.array(connectivities)
connectivities = sym_matrix_to_vec(connectivities)
shrunk_connectivities = [
shrunk_covariance_embedding(
cov_embedding=c,
prior_cov_approx=self.prior_cov_approx_,
shrinkage=self.shrinkage,
) for c in connectivities
]
return shrunk_connectivities
def test_connectivity_measure_outputs():
n_subjects = 10
n_features = 49
# Generate signals and compute covariances
emp_covs = []
ledoit_covs = []
signals = []
ledoit_estimator = LedoitWolf()
for k in range(n_subjects):
n_samples = 200 + k
signal, _, _ = generate_signals(n_features=n_features, n_confounds=5,
length=n_samples, same_variance=False)
signals.append(signal)
signal -= signal.mean(axis=0)
emp_covs.append((signal.T).dot(signal) / n_samples)
ledoit_covs.append(ledoit_estimator.fit(signal).covariance_)
kinds = ["covariance", "correlation", "tangent", "precision",
"partial correlation"]
# Check outputs properties
for cov_estimator, covs in zip([EmpiricalCovariance(), LedoitWolf()],
[emp_covs, ledoit_covs]):
input_covs = copy.copy(covs)
for kind in kinds:
conn_measure = ConnectivityMeasure(kind=kind,
cov_estimator=cov_estimator)
connectivities = conn_measure.fit_transform(signals)
# Generic
assert_true(isinstance(connectivities, np.ndarray))
assert_equal(len(connectivities), len(covs))
for k, cov_new in enumerate(connectivities):
assert_array_equal(input_covs[k], covs[k])
assert(is_spd(covs[k], decimal=7))
# Positive definiteness if expected and output value checks
if kind == "tangent":
assert_array_almost_equal(cov_new, cov_new.T)
gmean_sqrt = _map_eigenvalues(np.sqrt,
conn_measure.mean_)
assert(is_spd(gmean_sqrt, decimal=7))
assert(is_spd(conn_measure.whitening_, decimal=7))
assert_array_almost_equal(conn_measure.whitening_.dot(
gmean_sqrt), np.eye(n_features))
assert_array_almost_equal(gmean_sqrt.dot(
_map_eigenvalues(np.exp, cov_new)).dot(gmean_sqrt),
covs[k])
elif kind == "precision":
assert(is_spd(cov_new, decimal=7))
assert_array_almost_equal(cov_new.dot(covs[k]),
np.eye(n_features))
elif kind == "correlation":
assert(is_spd(cov_new, decimal=7))
d = np.sqrt(np.diag(np.diag(covs[k])))
if cov_estimator == EmpiricalCovariance():
assert_array_almost_equal(d.dot(cov_new).dot(d),
covs[k])
assert_array_almost_equal(np.diag(cov_new),
np.ones((n_features)))
elif kind == "partial correlation":
prec = linalg.inv(covs[k])
d = np.sqrt(np.diag(np.diag(prec)))
assert_array_almost_equal(d.dot(cov_new).dot(d), -prec +
2 * np.diag(np.diag(prec)))
# Check the mean_
for kind in kinds:
conn_measure = ConnectivityMeasure(kind=kind)
conn_measure.fit_transform(signals)
assert_equal((conn_measure.mean_).shape, (n_features, n_features))
if kind != 'tangent':
assert_array_almost_equal(
conn_measure.mean_,
np.mean(conn_measure.transform(signals), axis=0))
# Check that the mean isn't modified in transform
conn_measure = ConnectivityMeasure(kind='covariance')
conn_measure.fit(signals[:1])
mean = conn_measure.mean_
conn_measure.transform(signals[1:])
assert_array_equal(mean, conn_measure.mean_)
# Check vectorization option
for kind in kinds:
conn_measure = ConnectivityMeasure(kind=kind)
connectivities = conn_measure.fit_transform(signals)
conn_measure = ConnectivityMeasure(vectorize=True, kind=kind)
vectorized_connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(vectorized_connectivities,
sym_matrix_to_vec(connectivities))
# Check not fitted error
assert_raises_regex(
ValueError, 'has not been fitted. ',
ConnectivityMeasure().inverse_transform,
vectorized_connectivities)
# Check inverse transformation
kinds.remove('tangent')
for kind in kinds:
# without vectorization: input matrices are returned with no change
conn_measure = ConnectivityMeasure(kind=kind)
connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(
conn_measure.inverse_transform(connectivities), connectivities)
# with vectorization: input vectors are reshaped into matrices
# if diagonal has not been discarded
conn_measure = ConnectivityMeasure(kind=kind, vectorize=True)
vectorized_connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(
conn_measure.inverse_transform(vectorized_connectivities),
connectivities)
# with vectorization if diagonal has been discarded
for kind in ['correlation', 'partial correlation']:
connectivities = ConnectivityMeasure(kind=kind).fit_transform(signals)
conn_measure = ConnectivityMeasure(kind=kind, vectorize=True,
discard_diagonal=True)
vectorized_connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(
conn_measure.inverse_transform(vectorized_connectivities),
connectivities)
for kind in ['covariance', 'precision']:
connectivities = ConnectivityMeasure(kind=kind).fit_transform(signals)
conn_measure = ConnectivityMeasure(kind=kind, vectorize=True,
discard_diagonal=True)
vectorized_connectivities = conn_measure.fit_transform(signals)
diagonal = np.array([np.diagonal(conn) / sqrt(2) for conn in
connectivities])
inverse_transformed = conn_measure.inverse_transform(
vectorized_connectivities, diagonal=diagonal)
assert_array_almost_equal(inverse_transformed, connectivities)
assert_raises_regex(ValueError,
'can not reconstruct connectivity matrices',
conn_measure.inverse_transform,
vectorized_connectivities)
# for 'tangent' kind, covariance matrices are reconstructed
# without vectorization
tangent_measure = ConnectivityMeasure(kind='tangent')
displacements = tangent_measure.fit_transform(signals)
covariances = ConnectivityMeasure(kind='covariance').fit_transform(
signals)
assert_array_almost_equal(
tangent_measure.inverse_transform(displacements), covariances)
# with vectorization
# when diagonal has not been discarded
tangent_measure = ConnectivityMeasure(kind='tangent', vectorize=True)
vectorized_displacements = tangent_measure.fit_transform(signals)
assert_array_almost_equal(
tangent_measure.inverse_transform(vectorized_displacements),
covariances)
# when diagonal has been discarded
tangent_measure = ConnectivityMeasure(kind='tangent', vectorize=True,
discard_diagonal=True)
vectorized_displacements = tangent_measure.fit_transform(signals)
diagonal = np.array([np.diagonal(matrix) / sqrt(2) for matrix in
displacements])
inverse_transformed = tangent_measure.inverse_transform(
vectorized_displacements, diagonal=diagonal)
assert_array_almost_equal(inverse_transformed, covariances)
assert_raises_regex(ValueError,
'can not reconstruct connectivity matrices',
tangent_measure.inverse_transform,
vectorized_displacements)
def test_connectivity_measure_outputs():
n_subjects = 10
n_features = 49
# Generate signals and compute covariances
emp_covs = []
ledoit_covs = []
signals = []
ledoit_estimator = LedoitWolf()
for k in range(n_subjects):
n_samples = 200 + k
signal, _, _ = generate_signals(n_features=n_features, n_confounds=5,
length=n_samples, same_variance=False)
signals.append(signal)
signal -= signal.mean(axis=0)
emp_covs.append((signal.T).dot(signal) / n_samples)
ledoit_covs.append(ledoit_estimator.fit(signal).covariance_)
kinds = ["covariance", "correlation", "tangent", "precision",
"partial correlation"]
# Check outputs properties
for cov_estimator, covs in zip([EmpiricalCovariance(), LedoitWolf()],
[emp_covs, ledoit_covs]):
input_covs = copy.copy(covs)
for kind in kinds:
conn_measure = ConnectivityMeasure(kind=kind,
cov_estimator=cov_estimator)
connectivities = conn_measure.fit_transform(signals)
# Generic
assert isinstance(connectivities, np.ndarray)
assert len(connectivities) == len(covs)
for k, cov_new in enumerate(connectivities):
assert_array_equal(input_covs[k], covs[k])
assert(is_spd(covs[k], decimal=7))
# Positive definiteness if expected and output value checks
if kind == "tangent":
assert_array_almost_equal(cov_new, cov_new.T)
gmean_sqrt = _map_eigenvalues(np.sqrt,
conn_measure.mean_)
assert(is_spd(gmean_sqrt, decimal=7))
assert(is_spd(conn_measure.whitening_, decimal=7))
assert_array_almost_equal(conn_measure.whitening_.dot(
gmean_sqrt), np.eye(n_features))
assert_array_almost_equal(gmean_sqrt.dot(
_map_eigenvalues(np.exp, cov_new)).dot(gmean_sqrt),
covs[k])
elif kind == "precision":
assert(is_spd(cov_new, decimal=7))
assert_array_almost_equal(cov_new.dot(covs[k]),
np.eye(n_features))
elif kind == "correlation":
assert(is_spd(cov_new, decimal=7))
d = np.sqrt(np.diag(np.diag(covs[k])))
if cov_estimator == EmpiricalCovariance():
assert_array_almost_equal(d.dot(cov_new).dot(d),
covs[k])
assert_array_almost_equal(np.diag(cov_new),
np.ones((n_features)))
elif kind == "partial correlation":
prec = linalg.inv(covs[k])
d = np.sqrt(np.diag(np.diag(prec)))
assert_array_almost_equal(d.dot(cov_new).dot(d), -prec +
2 * np.diag(np.diag(prec)))
# Check the mean_
for kind in kinds:
conn_measure = ConnectivityMeasure(kind=kind)
conn_measure.fit_transform(signals)
assert (conn_measure.mean_).shape == (n_features, n_features)
if kind != 'tangent':
assert_array_almost_equal(
conn_measure.mean_,
np.mean(conn_measure.transform(signals), axis=0))
# Check that the mean isn't modified in transform
conn_measure = ConnectivityMeasure(kind='covariance')
conn_measure.fit(signals[:1])
mean = conn_measure.mean_
conn_measure.transform(signals[1:])
assert_array_equal(mean, conn_measure.mean_)
# Check vectorization option
for kind in kinds:
conn_measure = ConnectivityMeasure(kind=kind)
connectivities = conn_measure.fit_transform(signals)
conn_measure = ConnectivityMeasure(vectorize=True, kind=kind)
vectorized_connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(vectorized_connectivities,
sym_matrix_to_vec(connectivities))
# Check not fitted error
with pytest.raises(ValueError, match='has not been fitted. '):
ConnectivityMeasure().inverse_transform(vectorized_connectivities)
# Check inverse transformation
kinds.remove('tangent')
for kind in kinds:
# without vectorization: input matrices are returned with no change
conn_measure = ConnectivityMeasure(kind=kind)
connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(
conn_measure.inverse_transform(connectivities), connectivities)
# with vectorization: input vectors are reshaped into matrices
# if diagonal has not been discarded
conn_measure = ConnectivityMeasure(kind=kind, vectorize=True)
vectorized_connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(
conn_measure.inverse_transform(vectorized_connectivities),
connectivities)
# with vectorization if diagonal has been discarded
for kind in ['correlation', 'partial correlation']:
connectivities = ConnectivityMeasure(kind=kind).fit_transform(signals)
conn_measure = ConnectivityMeasure(kind=kind, vectorize=True,
discard_diagonal=True)
vectorized_connectivities = conn_measure.fit_transform(signals)
assert_array_almost_equal(
conn_measure.inverse_transform(vectorized_connectivities),
connectivities)
for kind in ['covariance', 'precision']:
connectivities = ConnectivityMeasure(kind=kind).fit_transform(signals)
conn_measure = ConnectivityMeasure(kind=kind, vectorize=True,
discard_diagonal=True)
vectorized_connectivities = conn_measure.fit_transform(signals)
diagonal = np.array([np.diagonal(conn) / sqrt(2) for conn in
connectivities])
inverse_transformed = conn_measure.inverse_transform(
vectorized_connectivities, diagonal=diagonal)
assert_array_almost_equal(inverse_transformed, connectivities)
with pytest.raises(ValueError,
match='can not reconstruct connectivity matrices'):
conn_measure.inverse_transform(vectorized_connectivities)
# for 'tangent' kind, covariance matrices are reconstructed
# without vectorization
tangent_measure = ConnectivityMeasure(kind='tangent')
displacements = tangent_measure.fit_transform(signals)
covariances = ConnectivityMeasure(kind='covariance').fit_transform(
signals)
assert_array_almost_equal(
tangent_measure.inverse_transform(displacements), covariances)
# with vectorization
# when diagonal has not been discarded
tangent_measure = ConnectivityMeasure(kind='tangent', vectorize=True)
vectorized_displacements = tangent_measure.fit_transform(signals)
assert_array_almost_equal(
tangent_measure.inverse_transform(vectorized_displacements),
covariances)
# when diagonal has been discarded
tangent_measure = ConnectivityMeasure(kind='tangent', vectorize=True,
discard_diagonal=True)
vectorized_displacements = tangent_measure.fit_transform(signals)
diagonal = np.array([np.diagonal(matrix) / sqrt(2) for matrix in
displacements])
inverse_transformed = tangent_measure.inverse_transform(
vectorized_displacements, diagonal=diagonal)
assert_array_almost_equal(inverse_transformed, covariances)
with pytest.raises(ValueError,
match='can not reconstruct connectivity matrices'):
tangent_measure.inverse_transform(vectorized_displacements)