def run_test(training_size,
scoring_function,
parameter_bounds,
corr_kernel,
n_cluster,
prior='GCP',
log=True):
x_training = []
y_training = []
for i in range(training_size):
x = [
np.random.uniform(parameter_bounds[j][0], parameter_bounds[j][1])
for j in range(parameter_bounds.shape[0])
]
x_training.append(x)
y_training.append(scoring_function(x)[0])
if (prior == 'GP'):
gp = GaussianProcess(theta0=.1 * np.ones(parameter_bounds.shape[0]),
thetaL=0.001 * np.ones(parameter_bounds.shape[0]),
thetaU=10. * np.ones(parameter_bounds.shape[0]),
random_start=5,
nugget=nugget)
gp.fit(x_training, y_training)
likelihood = gp.reduced_likelihood_function_value_
else:
gcp = GaussianCopulaProcess(nugget=nugget,
corr=corr_kernel,
random_start=5,
normalize=True,
coef_latent_mapping=0.4,
n_clusters=n_clusters)
gcp.fit(x_training, y_training)
likelihood = gcp.reduced_likelihood_function_value_
if not log:
likelihood = np.exp(likelihood)
return likelihood
def run_test(training_size, scoring_function, parameter_bounds, corr_kernel, n_cluster, prior="GCP", log=True):
x_training = []
y_training = []
for i in range(training_size):
x = [
np.random.uniform(parameter_bounds[j][0], parameter_bounds[j][1]) for j in range(parameter_bounds.shape[0])
]
x_training.append(x)
y_training.append(scoring_function(x)[0])
if prior == "GP":
gp = GaussianProcess(
theta0=0.1 * np.ones(parameter_bounds.shape[0]),
thetaL=0.001 * np.ones(parameter_bounds.shape[0]),
thetaU=10.0 * np.ones(parameter_bounds.shape[0]),
random_start=5,
nugget=nugget,
)
gp.fit(x_training, y_training)
likelihood = gp.reduced_likelihood_function_value_
else:
gcp = GaussianCopulaProcess(
nugget=nugget,
corr=corr_kernel,
random_start=5,
normalize=True,
coef_latent_mapping=0.4,
n_clusters=n_clusters,
)
gcp.fit(x_training, y_training)
likelihood = gcp.reduced_likelihood_function_value_
if not log:
likelihood = np.exp(likelihood)
return likelihood
def find_best_candidate_with_GCP(X,
raw_Y,
mean_Y,
std_Y,
args,
rand_candidates,
verbose,
acquisition_function='Simple'):
corr_kernel = args[0]
n_clusters = args[1]
GCP_mapWithNoise = args[2]
GCP_useAllNoisyY = args[3]
GCP_model_noise = args[4]
nugget = args[5]
GCP_upperBound_coef = args[6]
mean_gcp = GaussianCopulaProcess(nugget=nugget,
corr=corr_kernel,
random_start=5,
n_clusters=n_clusters,
mapWithNoise=GCP_mapWithNoise,
useAllNoisyY=GCP_useAllNoisyY,
model_noise=GCP_model_noise,
try_optimize=True)
mean_gcp.fit(X, mean_Y, raw_Y, obs_noise=std_Y)
if (verbose == 2):
print('GCP theta :' + str(mean_gcp.theta))
if (acquisition_function == 'Simple'):
predictions = mean_gcp.predict(rand_candidates,
eval_MSE=False,
eval_confidence_bounds=False)
best_candidate_idx = np.argmax(predictions)
best_candidate = rand_candidates[best_candidate_idx]
if (verbose == 2):
print 'Hopefully :', best_candidate, predictions[
best_candidate_idx]
elif (acquisition_function == 'UCB'):
predictions,MSE,boundL,boundU = \
mean_gcp.predict(rand_candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = GCP_upperBound_coef)
best_candidate_idx = np.argmax(boundU)
best_candidate = rand_candidates[best_candidate_idx]
if (verbose == 2):
print 'Hopefully :', best_candidate, predictions[
best_candidate_idx], boundU[best_candidate_idx]
elif (acquisition_function == 'MaxLowerBound'):
predictions,MSE,boundL,boundU = \
mean_gcp.predict(rand_candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = GCP_upperBound_coef)
best_candidate_idx = np.argmax(boundL)
best_candidate = rand_candidates[best_candidate_idx]
if (verbose == 2):
print 'Hopefully :', best_candidate, predictions[
best_candidate_idx], boundL[best_candidate_idx], boundU[
best_candidate_idx]
elif (acquisition_function == 'EI'):
predictions,MSE = \
mean_gcp.predict(rand_candidates,eval_MSE=True,transformY=False) # we want the predictions in the GP space
y_best = np.max(mean_Y)
sigma = np.sqrt(MSE)
ei = [ gcp_compute_ei((rand_candidates[i]-mean_gcp.X_mean)/mean_gcp.X_std,predictions[i],sigma[i],y_best, \
mean_gcp.mapping,mean_gcp.mapping_derivative) \
for i in range(rand_candidates.shape[0]) ]
best_candidate_idx = np.argmax(ei)
best_candidate = rand_candidates[best_candidate_idx]
if (verbose == 2):
print 'Hopefully :', best_candidate, predictions[
best_candidate_idx], ei[best_candidate_idx]
else:
print('Acquisition function not handled...')
return best_candidate
candidates = np.asarray(candidates)
count = -1
fig = plt.figure()
for n_clusters in all_n_clusters:
count += 2
ax = fig.add_subplot(len(all_n_clusters),2,count)
ax.set_title("GCP prediction")
gcp = GaussianCopulaProcess(nugget = nugget,
corr = corr_kernel,
random_start = 5,
n_clusters = n_clusters,
coef_latent_mapping = coef_latent_mapping,
mapWithNoise = GCP_mapWithNoise,
useAllNoisyY = False,
model_noise = None,
try_optimize = True)
gcp.fit(x_training,y_training)
print '\nGCP fitted'
print 'Theta', gcp.theta
print 'Likelihood', np.exp(gcp.reduced_likelihood_function_value_)
predictions,MSE,boundL,boundU = \
gcp.predict(candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = 1.96,integratedPrediction=integratedPrediction)
pred_error = np.mean( (predictions - np.asarray(real_y) ) **2. )
print 'MSE', pred_error / (np.std(real_y) **2.)
candidates.append(x)
real_y.append(branin_f(x)[0])
real_y = np.asarray(real_y)
candidates = np.asarray(candidates)
for n_clusters in all_n_clusters:
fig = plt.figure()
ax = fig.add_subplot(1, 2, 1, projection='3d')
ax.set_title("GCP prediction")
gcp = GaussianCopulaProcess(nugget=nugget,
corr=corr_kernel,
random_start=5,
n_clusters=n_clusters,
coef_latent_mapping=coef_latent_mapping,
mapWithNoise=GCP_mapWithNoise,
useAllNoisyY=False,
model_noise=None,
try_optimize=True)
gcp.fit(x_training, y_training)
print '\nGCP fitted'
print 'Theta', gcp.theta
print 'Likelihood', np.exp(gcp.reduced_likelihood_function_value_)
predictions,MSE,boundL,boundU = \
gcp.predict(candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = 1.96,integratedPrediction=integratedPrediction)
pred_error = np.mean((predictions - np.asarray(real_y))**2.)
print 'MSE', pred_error
for j in range(2):
ax = fig.add_subplot(2,2,2*j+1)
ax.set_title("GCP prediction")
if(j == 0):
GCP_mapWithNoise = False
model_noise = None
else:
GCP_mapWithNoise = False
model_noise = 'EGN'
gcp = GaussianCopulaProcess(nugget = nugget,
corr = corr_kernel,
random_start = 5,
n_clusters = n_clusters,
mapWithNoise = GCP_mapWithNoise,
useAllNoisyY = False,
model_noise = model_noise ,
try_optimize = True)
gcp.fit(x_training,y_training,y_detailed,obs_noise=noise_obs)
print 'GCP fitted'
print 'Theta', gcp.theta
predictions,MSE,boundL,boundU = \
gcp.predict(abs,eval_MSE=True,eval_confidence_bounds=True,coef_bound = 1.96)
pred,MSE_bis = gcp.predict(abs,eval_MSE=True,transformY=False,eval_confidence_bounds=False,coef_bound = 1.96)
gp_boundL = pred - 1.96*np.sqrt(MSE_bis)
gp_boundU = pred + 1.96*np.sqrt(MSE_bis)
t_f_plot = [gcp.mapping(abs[i],f_plot[i],normalize=True) for i in range(len(f_plot))]
plt.title('Density estimation')
fig2 = plt.figure()
plt.title("GCP prediction")
n_rows = (n_clusters_max+1)/2
if not((n_clusters_max+1)% 2 == 0):
n_rows += 1
mf_plt_axis = np.asarray(range(100)) / 100.
mapping_functions_plot = []
for n_clusters in range(1,n_clusters_max+1):
gcp = GaussianCopulaProcess(nugget = nugget,
corr=corr_kernel,
random_start=5,
normalize = True,
coef_latent_mapping = 0.4,
n_clusters=n_clusters)
gcp.fit(x_training,y_training)
likelihood = gcp.reduced_likelihood_function_value_
print 'LGCP-'+str(n_clusters)+' fitted'
print 'Theta', gcp.theta
print 'Likelihood',likelihood
if(n_clusters > 1):
centers = np.asarray([gcp.centroids[i][0]* gcp.X_std + gcp.X_mean for i in range(gcp.n_clusters) ], dtype=np.int32)
m = np.mean(y_training)
s = np.std(y_training)
y_mean, y_std = gcp.raw_y_mean,gcp.raw_y_std
x_density_plot = (np.asarray ( range(np.int(m *100.- 100.*(s)*10.),np.int(m*100. + 100.*(s)*10.)) ) / 100. - y_mean)/ y_std
X_init = parameters
Y_init = list(mean_outputs)
if(save_plots):
save_data = np.asarray([X_init[:,0],np.asarray(Y_init)]).T
np.savetxt('data_plots/train_data_plot.csv',save_data,delimiter=',')
for i in range(nb_GCP_steps):
rand_candidates = utils.sample_candidates(n_candidates,parameter_bounds,isInt)
if(sampling_model == 'GCP'):
mean_gcp = GaussianCopulaProcess(nugget = nugget,
corr = corr_kernel,
random_start = 5,
n_clusters = n_clusters,
mapWithNoise = GCP_mapWithNoise,
useAllNoisyY = GCP_useAllNoisyY,
model_noise = GCP_model_noise,
try_optimize = True)
mean_gcp.fit(parameters,mean_outputs,raw_outputs,obs_noise=std_outputs)
if(acquisition_function == 'UCB'):
predictions,MSE,boundL,boundU = \
mean_gcp.predict(rand_candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = GCP_upperBound_coef)
best_candidate_idx = np.argmax(boundU)
best_candidate = rand_candidates[best_candidate_idx]
idx = np.argsort(rand_candidates[:,0])
s_candidates = rand_candidates[idx,0]
s_boundL = boundL[idx]
s_boundU = boundU[idx]
for j in range(2):
ax = fig.add_subplot(2, 2, 2 * j + 1)
ax.set_title("GCP prediction")
if (j == 0):
GCP_mapWithNoise = False
model_noise = None
else:
GCP_mapWithNoise = False
model_noise = 'EGN'
gcp = GaussianCopulaProcess(nugget=nugget,
corr=corr_kernel,
random_start=5,
n_clusters=n_clusters,
mapWithNoise=GCP_mapWithNoise,
useAllNoisyY=False,
model_noise=model_noise,
try_optimize=True)
gcp.fit(x_training, y_training, y_detailed, obs_noise=noise_obs)
print 'GCP fitted'
print 'Theta', gcp.theta
predictions,MSE,boundL,boundU = \
gcp.predict(abs,eval_MSE=True,eval_confidence_bounds=True,coef_bound = 1.96)
pred, MSE_bis = gcp.predict(abs,
eval_MSE=True,
transformY=False,
eval_confidence_bounds=False,
def run_test(training_size, prediction_size, function_name, corr_kernel, n_cluster, prior="GCP"):
scoring_function = functions[function_name]
parameter_bounds = all_parameter_bounds[function_name]
x_training = []
y_training = []
for i in range(training_size):
x = [
np.random.uniform(parameter_bounds[j][0], parameter_bounds[j][1]) for j in range(parameter_bounds.shape[0])
]
x_training.append(x)
y_training.append(scoring_function(x)[0])
if isInt:
x_training, y_training = compute_unique2(np.asarray(x_training, dtype=np.int32), np.asarray(y_training))
candidates = []
real_y = []
for i in range(prediction_size):
x = [
np.random.uniform(parameter_bounds[j][0], parameter_bounds[j][1]) for j in range(parameter_bounds.shape[0])
]
candidates.append(x)
real_y.append(scoring_function(x)[0])
real_y = np.asarray(real_y)
if isInt:
candidates = np.asarray(candidates, dtype=np.int32)
if prior == "GP":
gp = GaussianProcess(
theta0=0.1 * np.ones(parameter_bounds.shape[0]),
thetaL=0.001 * np.ones(parameter_bounds.shape[0]),
thetaU=10.0 * np.ones(parameter_bounds.shape[0]),
random_start=5,
nugget=nugget,
)
gp.fit(x_training, y_training)
pred = gp.predict(candidates)
likelihood = gp.reduced_likelihood_function_value_
else:
gcp = GaussianCopulaProcess(
nugget=nugget,
corr=corr_kernel,
random_start=5,
normalize=True,
coef_latent_mapping=coef_latent_mapping,
n_clusters=n_clusters,
)
gcp.fit(x_training, y_training)
likelihood = gcp.reduced_likelihood_function_value_
if not (integratedPrediction):
pred = gcp.predict(candidates)
else:
pred, _, _, _ = gcp.predict(
candidates, eval_MSE=True, eval_confidence_bounds=True, integratedPrediction=True
)
mse = np.mean((pred - real_y) ** 2.0)
# Normalize
mse = mse / (np.std(real_y) ** 2.0)
likelihood = np.exp(likelihood)
return [mse, likelihood]
X_init = parameters
Y_init = list(mean_outputs)
if (save_plots):
save_data = np.asarray([X_init[:, 0], np.asarray(Y_init)]).T
np.savetxt('data_plots/train_data_plot.csv', save_data, delimiter=',')
for i in range(nb_GCP_steps):
rand_candidates = utils.sample_candidates(n_candidates, parameter_bounds,
isInt)
if (sampling_model == 'GCP'):
mean_gcp = GaussianCopulaProcess(nugget=nugget,
corr=corr_kernel,
random_start=5,
n_clusters=n_clusters,
mapWithNoise=GCP_mapWithNoise,
useAllNoisyY=GCP_useAllNoisyY,
model_noise=GCP_model_noise,
try_optimize=True)
mean_gcp.fit(parameters,
mean_outputs,
raw_outputs,
obs_noise=std_outputs)
if (acquisition_function == 'UCB'):
predictions,MSE,boundL,boundU = \
mean_gcp.predict(rand_candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = GCP_upperBound_coef)
best_candidate_idx = np.argmax(boundU)
best_candidate = rand_candidates[best_candidate_idx]
idx = np.argsort(rand_candidates[:, 0])
candidates.append(x)
real_y.append(branin_f(x)[0])
real_y = np.asarray(real_y)
candidates = np.asarray(candidates)
for n_clusters in all_n_clusters:
fig = plt.figure()
ax = fig.add_subplot(1,2,1, projection='3d')
ax.set_title("GCP prediction")
gcp = GaussianCopulaProcess(nugget = nugget,
corr = corr_kernel,
random_start = 5,
n_clusters = n_clusters,
coef_latent_mapping = coef_latent_mapping,
mapWithNoise = GCP_mapWithNoise,
useAllNoisyY = False,
model_noise = None,
try_optimize = True)
gcp.fit(x_training,y_training)
print '\nGCP fitted'
print 'Theta', gcp.theta
print 'Likelihood', np.exp(gcp.reduced_likelihood_function_value_)
predictions,MSE,boundL,boundU = \
gcp.predict(candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = 1.96,integratedPrediction=integratedPrediction)
pred_error = np.mean( (predictions - np.asarray(real_y) ) **2. )
print 'MSE', pred_error
def find_best_candidate_with_GCP(X, raw_Y, mean_Y, std_Y, args, rand_candidates,verbose,acquisition_function='Simple'):
corr_kernel = args[0]
n_clusters = args[1]
GCP_mapWithNoise = args[2]
GCP_useAllNoisyY = args[3]
GCP_model_noise = args[4]
nugget = args[5]
GCP_upperBound_coef = args[6]
mean_gcp = GaussianCopulaProcess(nugget = nugget,
corr = corr_kernel,
random_start = 5,
n_clusters = n_clusters,
mapWithNoise = GCP_mapWithNoise,
useAllNoisyY = GCP_useAllNoisyY,
model_noise = GCP_model_noise,
try_optimize = True)
mean_gcp.fit(X,mean_Y,raw_Y,obs_noise=std_Y)
if(verbose == 2):
print ('GCP theta :'+str(mean_gcp.theta))
if(acquisition_function=='Simple'):
predictions = mean_gcp.predict(rand_candidates,eval_MSE=False,eval_confidence_bounds=False)
best_candidate_idx = np.argmax(predictions)
best_candidate = rand_candidates[best_candidate_idx]
if(verbose == 2):
print 'Hopefully :', best_candidate, predictions[best_candidate_idx]
elif(acquisition_function=='UCB'):
predictions,MSE,boundL,boundU = \
mean_gcp.predict(rand_candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = GCP_upperBound_coef)
best_candidate_idx = np.argmax(boundU)
best_candidate = rand_candidates[best_candidate_idx]
if(verbose == 2):
print 'Hopefully :', best_candidate, predictions[best_candidate_idx], boundU[best_candidate_idx]
elif(acquisition_function=='MaxLowerBound'):
predictions,MSE,boundL,boundU = \
mean_gcp.predict(rand_candidates,eval_MSE=True,eval_confidence_bounds=True,coef_bound = GCP_upperBound_coef)
best_candidate_idx = np.argmax(boundL)
best_candidate = rand_candidates[best_candidate_idx]
if(verbose == 2):
print 'Hopefully :', best_candidate, predictions[best_candidate_idx], boundL[best_candidate_idx],boundU[best_candidate_idx]
elif(acquisition_function=='EI'):
predictions,MSE = \
mean_gcp.predict(rand_candidates,eval_MSE=True,transformY=False) # we want the predictions in the GP space
y_best = np.max(mean_Y)
sigma = np.sqrt(MSE)
ei = [ gcp_compute_ei((rand_candidates[i]-mean_gcp.X_mean)/mean_gcp.X_std,predictions[i],sigma[i],y_best, \
mean_gcp.mapping,mean_gcp.mapping_derivative) \
for i in range(rand_candidates.shape[0]) ]
best_candidate_idx = np.argmax(ei)
best_candidate = rand_candidates[best_candidate_idx]
if(verbose == 2):
print 'Hopefully :', best_candidate, predictions[best_candidate_idx], ei[best_candidate_idx]
else:
print('Acquisition function not handled...')
return best_candidate
for n_clusters in all_n_clusters:
f=open('data_EI/cluster' + str(n_clusters) +'.csv','w')
f.write('x,y,pred,ei\n')
count += 1
ax = fig.add_subplot(len(all_n_clusters),1,count)
ax.set_title("GCP prediction")
gcp = GaussianCopulaProcess(nugget = nugget,
corr = corr_kernel,
random_start = 5,
n_clusters = n_clusters,
coef_latent_mapping = coef_latent_mapping,
mapWithNoise = GCP_mapWithNoise,
useAllNoisyY = False,
model_noise = None,
try_optimize = True)
gcp.fit(x_training,y_training)
print '\nGCP fitted'
print 'Theta', gcp.theta
print 'Likelihood', np.exp(gcp.reduced_likelihood_function_value_)
predictions = gcp.predict(candidates,eval_MSE=False,eval_confidence_bounds=False,coef_bound = 1.96,integratedPrediction=False)
pred,mse = gcp.predict(candidates,eval_MSE=True,transformY=False)
y_best =np.max(y_training)
sigma = np.sqrt(mse)
k += 1
idx_val = idx_val[idxk]
idxk = list(idx_val)
else:
return False,0
return True,idx_val[0]
params,output,m_o,std_o = get_exp_data(4001,495)
rand_candidates = utils.sample_random_candidates(1000,parameter_bounds,None,isInt=np.ones(5))
gcp = GaussianCopulaProcess(nugget = 1e-10,
corr= 'squared_exponential',
random_start=5,
n_clusters=1,
coef_latent_mapping = 0.1,
try_optimize=True)
gcp.fit(params,m_o,output,obs_noise=std_o)
gp = GaussianProcess(theta0= 0.1 ,
thetaL = 0.001,
random_start=1,
thetaU = 10.,
nugget=1e-10)
gp.fit(params,m_o)
gp_pred,sigma = gp.predict(rand_candidates,eval_MSE=True)
gp_bu = np.asarray(gp_pred) + 1.96*np.sqrt(sigma)
print gp.theta_
predictions,mse,bl,bu = gcp.predict(rand_candidates,eval_MSE=True,eval_confidence_bounds=True,integratedPrediction= False,coef_bound=.5)
plt.title('Density estimation')
fig2 = plt.figure()
plt.title("GCP prediction")
n_rows = (n_clusters_max + 1) / 2
if not ((n_clusters_max + 1) % 2 == 0):
n_rows += 1
mf_plt_axis = np.asarray(range(100)) / 100.
mapping_functions_plot = []
for n_clusters in range(1, n_clusters_max + 1):
gcp = GaussianCopulaProcess(nugget=nugget,
corr=corr_kernel,
random_start=5,
normalize=True,
coef_latent_mapping=0.4,
n_clusters=n_clusters)
gcp.fit(x_training, y_training)
likelihood = gcp.reduced_likelihood_function_value_
print 'LGCP-' + str(n_clusters) + ' fitted'
print 'Theta', gcp.theta
print 'Likelihood', likelihood
if (n_clusters > 1):
centers = np.asarray([
gcp.centroids[i][0] * gcp.X_std + gcp.X_mean
for i in range(gcp.n_clusters)
],
dtype=np.int32)
def run_test(training_size,
prediction_size,
function_name,
corr_kernel,
n_cluster,
prior='GCP'):
scoring_function = functions[function_name]
parameter_bounds = all_parameter_bounds[function_name]
x_training = []
y_training = []
for i in range(training_size):
x = [
np.random.uniform(parameter_bounds[j][0], parameter_bounds[j][1])
for j in range(parameter_bounds.shape[0])
]
x_training.append(x)
y_training.append(scoring_function(x)[0])
if (isInt):
x_training, y_training = compute_unique2(
np.asarray(x_training, dtype=np.int32), np.asarray(y_training))
candidates = []
real_y = []
for i in range(prediction_size):
x = [
np.random.uniform(parameter_bounds[j][0], parameter_bounds[j][1])
for j in range(parameter_bounds.shape[0])
]
candidates.append(x)
real_y.append(scoring_function(x)[0])
real_y = np.asarray(real_y)
if (isInt):
candidates = np.asarray(candidates, dtype=np.int32)
if (prior == 'GP'):
gp = GaussianProcess(theta0=.1 * np.ones(parameter_bounds.shape[0]),
thetaL=0.001 * np.ones(parameter_bounds.shape[0]),
thetaU=10. * np.ones(parameter_bounds.shape[0]),
random_start=5,
nugget=nugget)
gp.fit(x_training, y_training)
pred = gp.predict(candidates)
likelihood = gp.reduced_likelihood_function_value_
else:
gcp = GaussianCopulaProcess(nugget=nugget,
corr=corr_kernel,
random_start=5,
normalize=True,
coef_latent_mapping=coef_latent_mapping,
n_clusters=n_clusters)
gcp.fit(x_training, y_training)
likelihood = gcp.reduced_likelihood_function_value_
if not (integratedPrediction):
pred = gcp.predict(candidates)
else:
pred, _, _, _ = gcp.predict(candidates,
eval_MSE=True,
eval_confidence_bounds=True,
integratedPrediction=True)
mse = np.mean((pred - real_y)**2.)
# Normalize
mse = mse / (np.std(real_y)**2.)
likelihood = np.exp(likelihood)
return [mse, likelihood]
plt.title('Mapping functions')
fig2 = plt.figure()
plt.title("GCP prediction")
n_rows = (len(coefs))/2
if not(len(coefs)% 2 == 0):
n_rows += 1
mf_plt_axis = np.asarray(range(100)) / 100.
mapping_functions_plot = []
for j in range(len(coefs)):
gcp = GaussianCopulaProcess(nugget = nugget,
corr=corr_kernel,
random_start=5,
normalize = True,
coef_latent_mapping = coefs[j],
n_clusters=n_clusters)
gcp.fit(x_training,y_training)
likelihood = gcp.reduced_likelihood_function_value_
print 'LGCP coef '+str(coefs[j])+' fitted'
print 'Theta', gcp.theta
print 'Likelihood',likelihood
if(n_clusters > 1):
centers = np.asarray([gcp.centroids[i][0]* gcp.X_std + gcp.X_mean for i in range(n_clusters) ], dtype=np.int32)
candidates = np.atleast_2d(range(80)).T * 5
#simple_prediction = gcp.predict(candidates,integratedPrediction=False)
prediction = gcp.predict(candidates,integratedPrediction=integratedPrediction)
abs = range(0,400)
