(train_id[dur1:], train_id[:dur1])]
X1_prior = spatial_priors.SphericalPrior(X1train, hyparams=ratios)
X2_prior = spatial_priors.SphericalPrior(X2train, hyparams=ratios)
X3_prior = spatial_priors.SphericalPrior(X3train, hyparams=ratios)
temporal_prior = temporal_priors.SphericalPrior(delays=[0]) # no delays
# 5. [ banded ridge ] banded ridge regression _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
fit_banded_polar = models.estimate_stem_wmvnp(
[X1train, X2train, X3train],
Ytrain, [X1test_stim, X2test_stim, X3test_stim],
Ytest,
feature_priors=[X1_prior, X2_prior, X3_prior],
temporal_prior=temporal_prior,
ridges=alphas,
folds=loro1,
performance=True,
weights=True,
verbosity=False)
voxelwise_optimal_hyperparameters = fit_banded_polar['optima']
print('\nVoxelwise optimal hyperparameter shape: {0}'.format(
voxelwise_optimal_hyperparameters.shape))
# Faster conversion of kernel weights to primal weights via matrix multiplication
# each vector (new_alphas, lamda_ones, lamda_twos) contains v number of entries (e.g. voxels)
new_alphas = voxelwise_optimal_hyperparameters[:, -1]
lambda_ones = voxelwise_optimal_hyperparameters[:, 1]
lambda_twos = voxelwise_optimal_hyperparameters[:, 2]
def test_fullfit(n=100, p=50, population_optimal=False):
ridges = np.logspace(-3, 3, 10)
nridges = len(ridges)
ndelays = 5
delays = range(ndelays)
oo = get_abc_data(banded=True, n=n, p=p)
features_train, features_test, responses_train, responses_test = oo
features_sizes = [fs.shape[1] for fs in features_train]
hyparams = np.logspace(0, 3, 5)
spatial_priors = [
sps.SphericalPrior(features_sizes[0], hyparams=[1.]),
sps.SphericalPrior(features_sizes[1], hyparams=hyparams),
sps.SphericalPrior(features_sizes[2], hyparams=hyparams),
]
temporal_prior = tps.SphericalPrior(delays)
folds = tikutils.generate_trnval_folds(
responses_train.shape[0],
sampler='bcv',
nfolds=(1, 5),
)
folds = list(folds)
res = models.estimate_stem_wmvnp(
features_train,
responses_train,
features_test,
responses_test,
ridges=ridges,
normalize_kernel=True,
temporal_prior=temporal_prior,
feature_priors=spatial_priors,
weights=True,
performance=True,
predictions=True,
population_optimal=population_optimal,
folds=(1, 5),
method='SVD',
verbosity=1,
cvresults=None,
)
for rdx in range(responses_train.shape[-1]):
if population_optimal:
assert res['optima'].shape[0] == 1
optima = res['optima'][0]
else:
optima = res['optima'][rdx]
temporal_opt, spatial_opt, ridge_scale = optima[0], optima[
1:-1], optima[-1]
Ktrain = 0.
Ktest = 0.
this_temporal_prior = temporal_prior.get_prior(hhparam=temporal_opt)
for fdx, (fs_train, fs_test, fs_prior, fs_hyper) in enumerate(
zip(features_train, features_test, spatial_priors,
spatial_opt)):
Ktrain += models.kernel_spatiotemporal_prior(
fs_train,
this_temporal_prior,
fs_prior.get_prior(fs_hyper),
delays=temporal_prior.delays)
if fs_test is not None:
Ktest += models.kernel_spatiotemporal_prior(
fs_train,
this_temporal_prior,
fs_prior.get_prior(fs_hyper),
delays=temporal_prior.delays,
Xtest=fs_test)
if np.allclose(Ktest, 0.0):
Ktest = None
# solve for this response
response_solution = models.solve_l2_dual(Ktrain,
responses_train[:, [rdx]],
Ktest=Ktest,
Ytest=responses_test[:,
[rdx]],
ridges=[ridge_scale],
performance=True,
predictions=True,
weights=True,
verbose=1,
method='SVD')
for k, v in response_solution.items():
# compare each vector output
assert np.allclose(res[k][:, rdx].squeeze(),
response_solution[k].squeeze())
# solution_svd_bandstd2tik = np.dot(Cinv, solution_svd_standard)
#
# print(np.rad2deg(angle), ratio, alpha, lambda_one, lambda_two)
# Use tikreg to find the solution
X1_prior = spatial_priors.SphericalPrior(X1train, hyparams=ratios)
X2_prior = spatial_priors.SphericalPrior(X2train, hyparams=ratios)
# A temporal prior is unnecessary, so we specify no delays
temporal_prior = temporal_priors.SphericalPrior(delays=[0]) # no delays
fit_banded_polar = models.estimate_stem_wmvnp(
[X1train, X2train],
Ytrain,
[X1test_stim, X2test_stim],
Ytest,
feature_priors=[X1_prior, X2_prior],
temporal_prior=temporal_prior,
ridges=alphas,
folds=(1, 5), # 1x 5-fold cross-validation
performance=True,
weights=True,
verbosity=False)
voxelwise_optimal_hyperparameters = fit_banded_polar['optima']
print('\nVoxelwise optimal hyperparameter shape:',
voxelwise_optimal_hyperparameters.shape)
# kernel_weights = fit_banded_polar['weights']
# primal_weights = []
# for voxid, (temporal_lambda, lambda_one, lambda_two, alpha) in enumerate(voxelwise_optimal_hyperparameters):
# ws = np.dot(np.hstack([X1train/lambda_one**2, X2train/lambda_two**2]).T, kernel_weights[:,voxid]*alpha)
# primal_weights.append(ws)
# primal_weights = np.asarray(primal_weights).T
# print(primal_weights.shape)
