def sor_loss(x_opt,
X,
y,
cv,
jitter,
disable_pbar=True,
leave=False,
return_score=False):
Lambda = x_opt[0]
kMM = X[0]
kMN = X[1]
Mactive, Nsample = kMN.shape
mse = 0
y_p = np.zeros((Nsample, ))
scores = []
for train, test in tqdm_cs(cv.split(kMN.T),
total=cv.n_splits,
disable=disable_pbar,
leave=False):
# prepare SoR kernel
kMN_train = kMN[:, train]
kernel_train = kMM + np.dot(kMN_train,
kMN_train.T) / Lambda**2 + np.diag(
np.ones(Mactive)) * jitter
y_train = np.dot(kMN_train, y[train]) / Lambda**2
# train the KRR model
alpha = np.linalg.solve(kernel_train, y_train).flatten()
# make predictions
kernel_test = kMN[:, test]
y_pred = np.dot(alpha, kernel_test).flatten()
if return_score is True:
scores.append(get_score(y_pred, y[test]))
#y_p[test] = y_pred
mse += np.sum((y_pred - y[test])**2)
mse /= len(y)
if return_score is True:
#score = get_score(y_p,y)
score = {}
for k in scores[0]:
aa = []
for sc in scores:
aa.append(sc[k])
score[k] = np.mean(aa)
return score
return mse
def soap_cov_loss(x_opt,
rawsoaps,
y,
cv,
jitter,
disable_pbar=True,
leave=False,
compressor=None,
active_ids=None,
return_score=False):
Lambda = x_opt[0]
fj = x_opt[1:]
compressor.set_scaling_weights(fj)
X = compressor.transform(rawsoaps)
X_pseudo = X[active_ids]
kMM = np.dot(X_pseudo, X_pseudo.T)
kMN = np.dot(X_pseudo, X.T)
Mactive, Nsample = kMN.shape
mse = 0
y_p = np.zeros((Nsample, ))
for train, test in tqdm_cs(cv.split(rawsoaps),
total=cv.n_splits,
disable=disable_pbar,
leave=False):
# prepare SoR kernel
kMN_train = kMN[:, train]
kernel_train = (kMM + np.dot(kMN_train, kMN_train.T) /
Lambda**2) + np.diag(np.ones(Mactive)) * jitter
y_train = np.dot(kMN_train, y[train]) / Lambda**2
# train the KRR model
alpha = np.linalg.solve(kernel_train, y_train).flatten()
# make predictions
kernel_test = kMN[:, test]
y_pred = np.dot(alpha, kernel_test).flatten()
if return_score is True:
y_p[test] = y_pred
mse += np.sum((y_pred - y[test])**2)
mse /= len(y)
if return_score is True:
score = get_score(y_p, y)
return score
return mse
def sor_fj_loss(x_opt,
data,
y,
cv,
jitter,
disable_pbar=True,
leave=False,
kernel=None,
compressor=None,
strides=None,
active_strides=None,
stride_size=None,
return_score=False):
Lambda = x_opt[0]
scaling_factors = x_opt[1:]
compressor.to_reshape = False
compressor.set_scaling_weights(scaling_factors)
unlinsoaps = data[0]
unlinsoaps_active = data[1]
X = compressor.scale_features(unlinsoaps, stride_size)
X_active = compressor.scale_features(unlinsoaps_active, stride_size)
# X = compressor.transform(unlinsoaps)
# X_active = compressor.transform(unlinsoaps_active)
if strides is not None and active_strides is not None:
X_active = dict(strides=active_strides, feature_matrix=X_active)
X = dict(strides=strides, feature_matrix=X)
kMM = kernel.transform(X_active, X_train=X_active)
kMN = kernel.transform(X_active, X_train=X)
Mactive, Nsample = kMN.shape
mse = 0
y_p = np.zeros((Nsample, ))
scores = []
for train, test in tqdm_cs(cv.split(y.reshape((-1, 1))),
total=cv.n_splits,
disable=disable_pbar,
leave=False):
# prepare SoR kernel
kMN_train = kMN[:, train]
kernel_train = (kMM + np.dot(kMN_train, kMN_train.T) /
Lambda**2) + np.diag(np.ones(Mactive)) * jitter
y_train = np.dot(kMN_train, y[train]) / Lambda**2
# train the KRR model
alpha = np.linalg.solve(kernel_train, y_train).flatten()
# make predictions
kernel_test = kMN[:, test]
y_pred = np.dot(alpha, kernel_test).flatten()
if return_score is True:
scores.append(get_score(y_pred, y[test]))
#y_p[test] = y_pred
mse += np.sum((y_pred - y[test])**2)
mse /= len(y)
if return_score is True:
#score = get_score(y_p,y)
score = {}
for k in scores[0]:
aa = []
for sc in scores:
aa.append(sc[k])
score[k] = np.mean(aa)
return score
return mse
for N_active_sample in tqdm_cs(N_active_samples,
desc='N_active_sample',
leave=False):
active_ids = fps_ids[:N_active_sample]
kMM = Kmat[np.ix_(active_ids, active_ids)]
for Lambda in tqdm_cs(Lambdas, desc='Lambda', leave=False):
preds = []
y_pred = np.zeros(y_train.shape)
for train, test in tqdm_cs(cv.split(Kmat),
desc='cv',
total=cv.n_splits,
leave=False):
kMN = Kmat[np.ix_(active_ids, train)]
## assumes Lambda= Lambda**2*np.diag(np.ones(n))
sparseK = kMM + np.dot(kMN, kMN.T) / Lambda
sparseY = np.dot(kMN, y_train[train]) / Lambda
Ktest = Kmat[np.ix_(test, active_ids)]
krr.fit(sparseK, sparseY)
y_pred[test] = krr.predict(Ktest)
sc = get_score(y_pred, y_train)
sc.update(
dict(N_active_sample=N_active_sample,
delta=delta,
Lambda=Lambda))
print sc
scores.append(sc)
df = pd.DataFrame(scores)
df.to_json(fn_out)
kMN_train = kMN[:,train]
k_train = kMM + np.dot(kMN_train,kMN_train.T)/Lambda**2 + np.diag(np.ones(Mactive))*jitter
y_train = np.dot(kMN_train,y[train])/Lambda**2
k_test = kMN[:,test]
else:
Ntrain = len(train)
k_train = Kmat[np.ix_(train,train)] + np.diag(np.ones(Ntrain))*jitter
y_train = y[train]
k_test = Kmat[np.ix_(train,test)]
alpha = np.linalg.solve(k_train, y_train).flatten()
y_pred = np.dot(alpha,k_test).flatten()
#model.fit(k_train,y_train)
#y_pred = model.predict(k_test)
sc = get_score(y_pred,y[test])
dd = dict(Ntrain = len(train), Ntest = len(test),iter=ii)
sc.update(**dd)
scores.append(sc)
results['results'].append(dict(y_pred=y_pred,y_true=y[test],iter=ii,
Ntrain = len(train), Ntest = len(test)))
df = pd.DataFrame(scores)
df.to_json(scores_fn)
dump_pck(results_fn,results)
ii += 1
print('Finished')