def predict(self, ys, paradigm, use_beta=True):
"""
"""
check_is_fitted(self, "hrf_")
names, onsets, durations, modulation = check_paradigm(paradigm)
frame_times = np.arange(0, onsets.max() + self.time_offset, self.t_r)
f_hrf = interp1d(self.hx_, self.hrf_)
dm = make_design_matrix_hrf(frame_times, paradigm,
hrf_length=self.hrf_length,
t_r=self.t_r, time_offset=self.time_offset,
drift_model=self.drift_model,
period_cut=self.period_cut,
drift_order=self.drift_order,
f_hrf=f_hrf)
# Least squares estimation
if use_beta:
beta_values = self.beta
else:
beta_values = np.linalg.pinv(dm.values).dot(ys)
#print dm.shape
#print beta_values.shape
ys_fit = dm.values[:, :len(beta_values)].dot(beta_values)
#ys -= drifts.dot(np.linalg.pinv(drifts).dot(ys))
ress = ys - ys_fit
return ys_fit, dm, beta_values, ress
fmin_max_iter=fmin_max_iter, sigma_noise=1.0,
time_offset=time_offset, n_iter=n_iter,
normalize_y=normalize_y, verbose=True,
optimize=optimize,
n_restarts_optimizer=n_restarts_optimizer,
zeros_extremes=zeros_extremes, f_mean=f_hrf)
(hx, hy, hrf_var, resid_norm_sq, sigma_sq_resid) = gp.fit(ys, paradigm)
print 'residual norm square = ', resid_norm_sq
# make the design matrix using estimated hrf
f_hrf_est = interp1d(hx, hy)
from data_generator import make_design_matrix_hrf
dm2 = make_design_matrix_hrf(frametimes, paradigm=paradigm,
hrf_length=hrf_length, t_r=t_r, time_offset=time_offset,
f_hrf=f_hrf_est)
# Predict using the betas with GP
ys_pred, matrix, betas, resid = gp.predict(ysr2, paradigm)
# Prepare data for GLM
mask_img = nb.Nifti1Image(np.ones((2, 2, 2)), affine=np.eye(4))
masker = NiftiMasker(mask_img=mask_img)
masker.fit()
ys2 = np.ones((2, 2, 2, ys.shape[0])) * ysr2[np.newaxis, np.newaxis, np.newaxis, :]
niimgs = nb.Nifti1Image(ys2, affine=np.eye(4))
# Re-estimate with a GLM on run 2 with dm
def get_values(simulation_peak, estimation_peak, held_out_index,
noise_level, noise_vector_list,
paradigms=paradigms, frame_times_run=frame_times_run,
beta=beta, new_betas=new_betas):
simulation_hrf = _gamma_difference_hrf(tr=1., oversampling=20,
time_length=hrf_length,
undershoot=16., delay=simulation_peak)
xs = np.linspace(0., hrf_length + 1, len(simulation_hrf), endpoint=False)
f_sim_hrf = interp1d(xs, simulation_hrf)
shifted_paradigms = [paradigm.copy()
for i, paradigm in enumerate(paradigms)
if i != held_out_index]
shifted_frame_times = []
offset = 0
# shift paradigms to concatenate them
for paradigm in shifted_paradigms:
paradigm_length = paradigm['onset'].max()
paradigm['onset'] += offset
shifted_frame_times.append(frame_times_run + offset)
offset += paradigm_length + time_offset
shifted_frame_times = np.concatenate(shifted_frame_times)
train_paradigm = pandas.concat(shifted_paradigms)
test_paradigm = paradigms[held_out_index]
train_noise = np.concatenate(
[noise for i, noise in enumerate(noise_vector_list)
if i != held_out_index])
scaled_train_noise = train_noise[:, np.newaxis] * noise_level
#test_noise = noise_vectors[held_out_index]
# design matrix dataframes
train_design_gen_df = make_design_matrix_hrf(shifted_frame_times,
train_paradigm, f_hrf=f_sim_hrf)
test_design_gen_df = make_design_matrix_hrf(frame_times_run,
test_paradigm, f_hrf=f_sim_hrf)
# design matrix without drifts
train_design_gen = train_design_gen_df[event_types].values
test_design_gen = test_design_gen_df[event_types].values
y_train_clean = train_design_gen.dot(beta)
y_train_norm = np.linalg.norm(y_train_clean) ** 2
y_train_noisy = y_train_clean[:, np.newaxis] + np.linalg.norm(y_train_clean) * scaled_train_noise
y_train_noisy_norm = np.linalg.norm(y_train_noisy, axis=0) ** 2
#train_signal_norm[i_sim, held_out_index, :] = y_train_noisy_norm
y_test = test_design_gen.dot(beta)
y_test_new = test_design_gen.dot(new_betas)
y_test_norm = np.linalg.norm(y_test) ** 2
y_test_new_norm = np.linalg.norm(y_test_new, axis=0) ** 2
#test_signal_norm[i_sim, held_out_index, :] = y_test_norm
#new_test_signal_norm[i_sim, held_out_index, :] = y_test_new_norm
beta_hat_gen = np.linalg.pinv(train_design_gen).dot(y_train_noisy)
train_gen_resid = np.linalg.norm(y_train_noisy -
train_design_gen.dot(beta_hat_gen), axis=0) ** 2
#train_gen_train_gen[i_sim, held_out_index, :] = train_gen_resid
y_pred_gen = test_design_gen.dot(beta_hat_gen)
test_gen_resid = np.linalg.norm(y_test[:, np.newaxis] - y_pred_gen) ** 2
#train_gen_test_gen[i_sim, held_out_index, :] = test_gen_resid
#print("Generation peak {} Estimation peak {} Fold {}".format(simulation_peak, estimation_peak, held_out_index))
estimation_hrf = _gamma_difference_hrf(tr=1., oversampling=20,
time_length=hrf_length,
undershoot=16, delay=estimation_peak)
f_est_hrf = interp1d(xs, estimation_hrf)
# design matrix dataframes
train_design_est_df = make_design_matrix_hrf(shifted_frame_times,
train_paradigm, f_hrf=f_est_hrf)
test_design_est_df = make_design_matrix_hrf(frame_times_run,
test_paradigm, f_hrf=f_est_hrf)
# design matrix without drifts
train_design_est = train_design_est_df[event_types].values
test_design_est = test_design_est_df[event_types].values
beta_hat_est = np.linalg.pinv(train_design_est).dot(y_train_noisy)
train_est_resid = np.linalg.norm(y_train_noisy -
train_design_est.dot(beta_hat_est), axis=0) ** 2
#train_gen_train_est[i_sim, i_est, held_out_index, :] = train_est_resid
y_pred_est = test_design_est.dot(beta_hat_est)
test_est_resid = np.linalg.norm(y_test[:, np.newaxis] - y_pred_est, axis=0) ** 2
#train_gen_test_est[i_sim, i_est, held_out_index, :] = test_est_resid
y_test_squashed = test_design_est.dot(np.linalg.pinv(test_design_est).dot(y_test))
test_squashed_resid = np.linalg.norm(y_test - y_test_squashed, axis=0) ** 2
#test_est_test_est[i_sim, i_est, held_out_index, :] = test_squashed_resid
# now for some crazy hrf fitting
output = alternating_optimization(
train_paradigm, y_train_noisy,
hrf_length,
frame_times=shifted_frame_times,
mean=f_est_hrf,
n_alternations=10,
sigma_squared=1,
rescale_hrf=False,
optimize_kernel=True,
optimize_sigma_squared=False)
(betas, (hrf_measurement_points, hrf_measures),
residuals,
hrfs, lls, grads, looes, thetas, sigmas_squared) = output
hrf_measurement_points = np.concatenate(hrf_measurement_points)
order = np.argsort(hrf_measurement_points)
hrf_measurement_points = hrf_measurement_points[order]
hrf_measures = hrf_measures[order]
extra_points = np.array([0., -.1, hrf_length, hrf_length + 1.])
extra_values = np.zeros_like(extra_points)
hrf_func = interp1d(np.concatenate([hrf_measurement_points, extra_points]),
np.concatenate([hrf_measures, extra_points]))
fitted_train_resid = residuals[-1]
fitted_train_design_ = make_design_matrix_hrf(frame_times_run, train_paradigm,
f_hrf=hrf_func)
fitted_test_design_ = make_design_matrix_hrf(frame_times_run, test_paradigm,
f_hrf=hrf_func)
fitted_train_design = fitted_train_design_[event_types].values
fitted_test_design = fitted_test_design_[event_types].values
ftd_sparsity = np.abs(fitted_test_design).sum(axis=0) / np.sqrt((fitted_test_design ** 2).sum(axis=0))
if (ftd_sparsity < 2.).any():
#print('Spike at sim {} est {} ho {} noise {}'.format(simulation_peak, estimation_peak, held_out_index, noise_level))
#print('Removing strongest entry')
spiking = ftd_sparsity < 2.
d = fitted_test_design[:, spiking]
location = np.abs(d).argmax(0)
d[location, np.arange(len(location))] = .5 * (d[location - 1, np.arange(len(location))] +
d[location + 1, np.arange(len(location))])
fitted_test_design[:, spiking] = d
reest_betas = np.linalg.pinv(fitted_train_design).dot(y_train_noisy)
# fitted_test_pred = fitted_test_design.dot(reest_betas)
fitted_test_pred = fitted_test_design.dot(betas)
fitted_test_resid = np.linalg.norm(y_test - fitted_test_pred) ** 2
fitted_test_squashed_pred = fitted_test_design.dot(
np.linalg.pinv(fitted_test_design).dot(y_test_new))
fitted_test_squashed_resid = np.linalg.norm(
y_test_new - fitted_test_squashed_pred, axis=0) ** 2
# now do exactly the same thing again for 0 mean ...
# I know it is redundant
output = alternating_optimization(
train_paradigm, y_train_noisy,
hrf_length,
frame_times=shifted_frame_times,
mean=zero_mean,
n_alternations=10,
sigma_squared=1,
rescale_hrf=False,
optimize_kernel=True,
optimize_sigma_squared=False)
(zm_betas, (zm_hrf_measurement_points, zm_hrf_measures),
zm_residuals,
zm_hrfs, zm_lls, zm_grads, zm_looes, zm_thetas, zm_sigmas_squared) = output
zm_hrf_measurement_points = np.concatenate(zm_hrf_measurement_points)
order = np.argsort(zm_hrf_measurement_points)
zm_hrf_measurement_points = zm_hrf_measurement_points[order]
zm_hrf_measures = zm_hrf_measures[order]
extra_points = np.array([0., -.1, hrf_length, hrf_length + 1.])
extra_values = np.zeros_like(extra_points)
zm_hrf_func = interp1d(np.concatenate([zm_hrf_measurement_points, extra_points]),
np.concatenate([zm_hrf_measures, extra_points]))
zm_fitted_train_resid = zm_residuals[-1]
zm_fitted_train_design_ = make_design_matrix_hrf(frame_times_run, train_paradigm,
f_hrf=zm_hrf_func)
zm_fitted_test_design_ = make_design_matrix_hrf(frame_times_run, test_paradigm,
f_hrf=zm_hrf_func)
zm_fitted_train_design = zm_fitted_train_design_[event_types].values
zm_fitted_test_design = zm_fitted_test_design_[event_types].values
ftd_sparsity = np.abs(zm_fitted_test_design).sum(axis=0) / np.sqrt((zm_fitted_test_design ** 2).sum(axis=0))
if (ftd_sparsity < 2.).any():
#print('Spike at sim {} est {} ho {} noise {}'.format(simulation_peak, estimation_peak, held_out_index, noise_level))
#print('Removing strongest entry')
spiking = ftd_sparsity < 2.
d = zm_fitted_test_design[:, spiking]
location = np.abs(d).argmax(0)
d[location, np.arange(len(location))] = .5 * (d[location - 1, np.arange(len(location))] +
d[location + 1, np.arange(len(location))])
zm_fitted_test_design[:, spiking] = d
zm_reest_betas = np.linalg.pinv(zm_fitted_train_design).dot(y_train_noisy)
# zm_fitted_test_pred = zm_fitted_test_design.dot(zm_reest_betas)
zm_fitted_test_pred = zm_fitted_test_design.dot(zm_betas)
zm_fitted_test_resid = np.linalg.norm(y_test - zm_fitted_test_pred) ** 2
zm_fitted_test_squashed_pred = zm_fitted_test_design.dot(
np.linalg.pinv(zm_fitted_test_design).dot(y_test_new))
zm_fitted_test_squashed_resid = np.linalg.norm(
y_test_new - zm_fitted_test_squashed_pred, axis=0) ** 2
return (train_paradigm, test_paradigm,
beta, betas, zm_betas, reest_betas, zm_reest_betas,
y_train_noisy, y_test, y_train_norm, y_train_noisy_norm, y_test_norm, y_test_new_norm,
train_gen_resid, test_gen_resid, train_est_resid, test_est_resid,
test_squashed_resid, fitted_train_resid, fitted_test_resid,
fitted_test_squashed_resid, hrf_measurement_points, hrf_measures,
zm_fitted_train_resid, zm_fitted_test_resid,
zm_fitted_test_squashed_resid, zm_hrf_measurement_points, zm_hrf_measures,
train_design_gen, test_design_gen, train_design_est, test_design_est,
fitted_train_design, fitted_test_design, zm_fitted_train_design, zm_fitted_test_design)
paradigm, design_, modulation, measurement_times = generate_experiment(
n_events=n_events,
n_blank_events=n_blank_events,
event_spacing=event_spacing,
t_r=t_r, hrf_length=hrf_length,
event_types=event_types,
jitter_min=jitter_min,
jitter_max=jitter_max,
time_offset=time_offset,
modulation=modulation,
return_jitter=True,
seed=seed)
design_ = make_design_matrix_hrf(measurement_times, paradigm, f_hrf=f_sim_hrf)
design = design_[event_types].values
rng = np.random.RandomState(seed)
beta = rng.randn(len(event_types))
y_clean = design.dot(beta)
noise = rng.randn(len(y_clean))
noise /= np.linalg.norm(noise)
y_noisy = y_clean + np.linalg.norm(y_clean) * noise * 2
kernel = RBF()
(betas, (hrf_measurement_points, hrf_measures),
residuals, hrfs, lls, grads, looes, thetas, sigmas_squared) = alternating_optimization(
paradigm, y_noisy,
hrf_length,
