def makeGaussianProcess(self):
tempNuggs = nm.reshape(nm.array(self.allNuggets), len(self.allNuggets))
if self.corrFixed:
self.gaussProcess = slgp.GaussianProcess(nugget=tempNuggs,
theta0=self.bestTheta)
self.gaussProcess.fit(self.allParams, self.allCosts)
self.gaussProcessParticles = []
self.gaussProcessParticles.append(self.gaussProcess)
else:
tempThetaParticles = self.logThetaParticles
self.logThetaParticles = []
self.logWeights = []
self.gaussProcessParticles = []
for ttp in tempThetaParticles:
testTheta = nm.exp(ttp)
#print("saved currTestTheta:" + str(testTheta))
self.gaussProcess = slgp.GaussianProcess(nugget=tempNuggs,
theta0=testTheta,
thetaL=self.minTheta,
thetaU=self.maxTheta)
self.gaussProcess.fit(self.allParams, self.allCosts)
self.saveParticles()
for _ in range(self.thetaSearchNumber):
testTheta = nm.power(
10, self.minLogTheta + nr.rand(self.numParams) *
(self.maxLogTheta - self.minLogTheta))
#print("random currTestTheta:" + str(testTheta))
self.gaussProcess = slgp.GaussianProcess(nugget=tempNuggs,
theta0=testTheta,
thetaL=self.minTheta,
thetaU=self.maxTheta)
self.gaussProcess.fit(self.allParams, self.allCosts)
self.saveParticles()
self.dropSmallParticles()
self.normWeights = nm.exp(nm.array(self.logWeights))
self.normWeights = self.normWeights / nm.sum(self.normWeights)
self.numParticles = len(self.normWeights)
#Diagnostics
maxLogWeight = max(self.logWeights)
thetaRef = self.logWeights.index(maxLogWeight)
self.bestTheta = 10.**self.logThetaParticles[thetaRef]
self.weightEntropy = -float(
nm.sum(self.normWeights * nm.log(self.normWeights)))
self.histBestTheta.append(nm.ravel(self.bestTheta))
self.histBestRLFV.append(maxLogWeight)
self.histNumParticles.append(self.numParticles)
self.histWeightEntropy.append(self.weightEntropy)
def demGaussians(trainData,testData,trainOuts,testOuts): clf = gaussian_process.GaussianProcess(theta0=1e-2, thetaL=1e-4, thetaU=1e-1) print(clf.fit(trainData,trainOuts)) predictions = clf.predict(testData) print(predictions) misses,error = sup.crunchTestResults(predictions,testOuts,.5) print(1-error)
def computeGaussianProcessApproximation(self):
#For the approximation
self.x_pred = np.atleast_2d(np.linspace(BOUND_L, BOUND_U, 200)).T
#GP call
gp = gaussian_process.GaussianProcess()
gp.fit(self.x_sample, self.y_sample)
self.y_pred, self.sigma2_pred = gp.predict(self.x_pred, eval_MSE=True)
def __gp(self,polls, parties, ax):
""" TODO
:param x:
:param ax:
:param partyname:
:return:
"""
for party in parties.parties.values():
polls_party = polls.get_party(party)
dates = [x[0] for x in polls_party]
votes = [x[1] for x in polls_party]
x = dates
y = votes
# + 0.5 - 0.5?
x_dense = np.atleast_2d(np.linspace(time.mktime(x[0].timetuple()),
time.mktime(x[-1].timetuple()), 1000)).T
#x_dense = np.atleast_2d(np.linspace(x[0], x[-1], 1000)).T
np.random.seed(1)
gp = gaussian_process.GaussianProcess(corr='squared_exponential', theta0=1e-1,
thetaL=1e-3, thetaU=1,
random_start=100, nugget=10 - 8)
x = [time.mktime(xi.timetuple()) for xi in x]
gp.fit(np.reshape(x, (-1, 1)) + np.random.randn(len(x),1)*0.01, np.reshape(y,(-1, 1)))
y_pred, mse = gp.predict(x_dense, eval_MSE=True)
sigma = np.sqrt(mse)
x_dense = [datetime.datetime.fromtimestamp(xi) for xi in x_dense]
ax.plot(x_dense, y_pred, 'b-', label=u'Prediction', c=party.color, linewidth=3)
def get_model(target,features,test_features,test_target): """ the list of models to try """ model_names = [ linear_model.LinearRegression(), linear_model.RidgeCV(alphas=[0.1, 1.0, 10.0]), tree.DecisionTreeRegressor(), gaussian_process.GaussianProcess(theta0=1e-2, thetaL=1e-4, thetaU=1e-1), SVR(kernel='linear', C=1e3), linear_model.BayesianRidge(), linear_model.SGDRegressor() ] i = 0 best_model = None best_score = 0 for model in model_names: mf = Model_fitter(model) if i >= 4: target=target.ravel() test_target = test_target.ravel() i+=1 mf.fit_data(features,target) mf.compute_score(test_features,test_target) # choose the model with least error if best_model is None: best_model = mf elif best_model.residual_error > mf.residual_error: best_model = mf return best_model
def bayesopt(f, initial_x, acquisition, niter=100, debug=False):
"""The actual bayesian optimization function.
f is the very expensive function we want to optimize.
initial_x is a matrix of at least two data points (preferrably
more, randomly sampled).
acquisition is the acquisiton function we want to use to find
query points.
Note that doing simulated annealing as done here is a very bad
idea, as we should be very careful about the domain."""
X = initial_x
y = [f(x) for x in initial_x]
best_x = initial_x[np.argmax(y)]
best_f = y[np.argmax(y)]
print y
gp = gaussian_process.GaussianProcess()
for i in xrange(niter):
gp.fit(np.array(X), np.array(y))
new_x = scipy.optimize.anneal(acquisition(gp, best_f), best_x)[0]
new_f = f(new_x)
X.append(new_x)
y.append(new_f)
if new_f > best_f:
best_f = new_f
best_x = new_x
if debug:
print "iter", i, "best_x", best_x, best_f
return best_x, best_f
def learnProb(self):
ndlen = len(self.nondomObs)
dlen = len(self.domObs)
if ndlen + dlen < 3:
return
if self.kernel == None:
self.kernel = gaussian_process.GaussianProcess(corr='cubic',
theta0=1e-2,
thetaL=1e-1,
thetaU=1e-1)
X = np.zeros((ndlen + dlen, self.dimNum))
Y = np.zeros((ndlen + dlen, 1))
for i in range(ndlen):
for d in range(self.dimNum):
X[i, d] = self.nondomObs[i][0, d]
Y[i, 0] = 0.8
for i in range(dlen):
for d in range(self.dimNum):
X[i + ndlen, d] = self.domObs[i][0, d]
Y[i + ndlen, 0] = 1e-4
#print X
#print Y
self.kernel.fit(X, Y)
def tune_GP(X_tr, y_tr):
param_space = {}
regressor = gaussian_process.GaussianProcess(theta0=0.1,
thetaL=.001,
thetaU=1.)
return tune(regressor, param_space, X_tr, y_tr)
def play_gpy(ntrain=10):
xtrain_ = np.random.uniform(low=-1.0, high=2.0, size=ntrain)
X_train = xtrain_.reshape(len(xtrain_), 1)
y_train = objective(X_train)
x_test = np.linspace(-1, 2, 1000)
gp = gaussian_process.GaussianProcess(theta0=1e-2, thetaL=1e-4, thetaU=1e-1)
gp.fit(X_train, y_train)
y_pred, sigma2_pred = gp.predict(x_test, eval_MSE=True)
sigma = np.sqrt(sigma2_pred)
fig = pl.figure()
pl.plot(x_test, f(x_test), 'r:', label=u'$f(x) = x\,\sin(x)$')
pl.plot(X_train, y_train, 'r.', markersize=10, label=u'Observations')
pl.plot(x_test, y_pred, 'b-', label=u'Prediction')
pl.fill(np.concatenate([x_test, x_test[::-1]]),
np.concatenate([y_pred - 1.9600 * sigma,
(y_pred + 1.9600 * sigma)[::-1]]),
alpha=.5, fc='b', ec='None', label='95% confidence interval')
pl.xlabel('$x$')
pl.ylabel('$f(x)$')
pl.ylim(-10, 20)
pl.legend(loc='upper left')
pl.show()
def test_Gaussian2D(self):
# http://scikit-learn.org/stable/auto_examples/gaussian_process/plot_gp_probabilistic_classification_after_regression.html
def g(x):
"""The function to predict (classification will then consist in predicting
whether g(x) <= 0 or not)"""
return 5. - x[:, 1] - .5 * x[:, 0]**2.
# Design of experiments
X = np.array([[-4.61611719, -6.00099547], [4.10469096, 5.32782448],
[0.00000000, -0.50000000], [-6.17289014, -4.6984743],
[1.3109306, -6.93271427], [-5.03823144, 3.10584743],
[-2.87600388, 6.74310541], [5.21301203, 4.26386883]])
y = g(X)
df = pdml.ModelFrame(X, target=y)
gpm1 = df.gaussian_process.GaussianProcess(theta0=5e-1)
df.fit(gpm1)
result, result_MSE = df.predict(gpm1, eval_MSE=True)
gpm2 = gp.GaussianProcess(theta0=5e-1)
gpm2.fit(X, y)
expected, expected_MSE = gpm2.predict(X, eval_MSE=True)
self.assert_numpy_array_almost_equal(result.values, expected)
self.assert_numpy_array_almost_equal(result_MSE.values, expected_MSE)
def build_surrogate(self):
"""Builds a surrogate based on sample evalations using a Guassian process.
Assumptions:
None
Source:
N/A
Inputs:
self.training.
coefficients [-] CL and CD
grid_points [radians,-] angles of attack and mach numbers
Outputs:
self.surrogates.
lift_coefficient <Guassian process surrogate>
drag_coefficient <Guassian process surrogate>
Properties Used:
No others
"""
# Unpack data
training = self.training
AoA_data = training.angle_of_attack
mach_data = training.Mach
CL_data = training.coefficients[:, 0]
CD_data = training.coefficients[:, 1]
xy = training.grid_points
# Gaussian Process New
regr_cl = gaussian_process.GaussianProcess()
regr_cd = gaussian_process.GaussianProcess()
cl_surrogate = regr_cl.fit(xy, CL_data)
cd_surrogate = regr_cd.fit(xy, CD_data)
self.surrogates.lift_coefficient = cl_surrogate
self.surrogates.drag_coefficient = cd_surrogate
AoA_points = np.linspace(-3., 11., 100) * Units.deg
mach_points = np.linspace(.02, .9, 100)
AoA_mesh, mach_mesh = np.meshgrid(AoA_points, mach_points)
CL_sur = np.zeros(np.shape(AoA_mesh))
CD_sur = np.zeros(np.shape(AoA_mesh))
return
def gaussianProcessing(trainFeature, trainLabel, testFeature, testLabel):
gp = gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
gp.fit(trainFeature, trainLabel)
predictLabel, sigma2_pred = gp.predict(testFeature, eval_MSE=True)
return (list(predictLabel * testLabel > 0).count(True) * 1.0 /
len(testLabel))
def __init__(self, isTrain):
super(RegressionGaussianProcess, self).__init__(isTrain)
# data preprocessing
#self.dataPreprocessing()
# Create Gaussian process object
self.gp = gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
def gpTestcase():
X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T
y = f(X).ravel()
x = np.atleast_2d(np.linspace(0, 10, 1000)).T
gp = gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
gp.fit(X, y)
logging.debug(str(gp))
def validate_gp_scikitlearn():
X = np.atleast_2d(np.linspace(-1, 1, 50)).T
y = f(X).ravel() + 0.2 * np.random.standard_normal()
x = np.atleast_2d(np.linspace(-1, 1, 1000)).T
gp = gaussian_process.GaussianProcess(theta0=1e-2, thetaL=1e-4, thetaU=1e-1)
gp.fit(X, y)
y_pred, sigma2_pred = gp.predict(x, eval_MSE=True)
print("MSE: ", np.mean( (f(x).ravel()-y_pred) ** 2))
print("Sigma: ", np.mean(sigma2_pred))
def fit_gaussian_process_baseline(self,
fit_fraction=0.2,
theta0=5.0,
nugget=1.0,
plot=True):
"""
Gaussian Process fit of baseline.
fit_fraction : float, default 0.2
fraction of baseline to use for fitting the GP.
theta0 : float 5.0, default 5.0
The parameters in the autocorrelation model.
nugget : float, default 1.0
Introduce a nugget effect to allow smooth predictions from noisy data.
plot : bool, default True
Generate plots of the baseline fit
:return:
:rtype:
"""
from sklearn import gaussian_process
# Retrieve a reduced set of data
# (data up until first injection and x percent before every injection)
fit_indices, x, y = self._retrieve_fit_indices(fit_fraction)
# sklearn requires a 2d array, so make it pseudo 2d
full_x = numpy.atleast_2d(self.filter_period_end_time).T
x = numpy.atleast_2d(x).T
full_y = numpy.array(self.differential_power).T
y = numpy.array(y).T
# TODO look into GaussianProcessRegressor http://bit.ly/2kpUs0b
# current API will be deprecated as of scikit learn 0.8
gp = gaussian_process.GaussianProcess(regr='quadratic',
corr='squared_exponential',
theta0=theta0,
nugget=nugget,
random_start=100)
# Fit only based on the reduced set of the data
gp.fit(x, y)
y_pred, mean_squared_error = gp.predict(full_x, eval_MSE=True)
sigma = numpy.sqrt(mean_squared_error)
self.baseline_power = Quantity(y_pred, 'microcalories per second')
self.baseline_fit_data = {
'x': full_x,
'y': y_pred,
'indices': fit_indices
}
self.baseline_subtracted = self.differential_power - self.baseline_power
if plot:
self._plot_gaussian_baseline(full_x, full_y, sigma, x, y, y_pred)
self._plot_baseline_subtracted(full_x, self.baseline_subtracted)
def surrogate_search():
## sample three times
iterations = 300
epsilon = 0.1
X, y = load_train_set()
#X,y = sample(X,y,0.1)
sc = Scorer(X, y)
min_v = [5, 0.001, 0.1]
max_v = [20, 0.1, 0.8]
root_state = State(min_v, max_v, K=3)
X = []
y = []
n_lims = np.array([min_v, max_v])
extremes = list(itertools.product(*n_lims.T))
for i, extreme in enumerate(extremes):
#draw = root_state.sample()
val = sc.score(extreme)
print "Extreme", i, extreme, val
X.append(extreme)
y.append(val)
for iteration in xrange(0, iterations):
## fit a regressor over the samples
#clf = DecisionTreeRegressor()
clf = gaussian_process.GaussianProcess()
clf.fit(X, y)
#print X, y, clf.predict(X)
#exit()
#plot_gp(X,y,root_state,clf)
best_node = stoSOO(root_state,
10000,
lambda x: clf.predict([x])[0],
verbose=False,
det=False,
output_dir="./Optimisation")
r = random.random()
if (r > epsilon):
draw = best_node.state.sample()
else:
draw = root_state.sample()
val = sc.score(draw)
X.append(draw)
y.append(val)
print "DRAW", draw, val
print "Best So Far", best_node, best_node.depth, best_node.state._n_splits
print "Surrogate Best", calc_best_from_node(best_node)
def GaussianProcessRegression(x_train, t_train, x_test, t_test):
deDupe(x_train, t_train)
gp = gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
gp.fit(x_train, t_train)
pred, sigma2_pred = gp.predict(x_test, eval_MSE=True)
error = computeError(pred, t_test)
save_model(gp, "GaussianProcessRegression", len(x_train), cal_only)
return {
"error": error,
"sigma2": sum(sigma2_pred.tolist()) / len(sigma2_pred.tolist())
}
def get_model(model_str):
if model_str == 'ET':
return ensemble.ExtraTreesRegressor(random_state=RANDOM_STATE)
elif model_str == 'RF':
return ensemble.RandomForestRegressor(random_state=RANDOM_STATE)
elif model_str == 'GP':
return gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=8e-1,
random_state=RANDOM_STATE)
elif model_str == 'KNN':
return neighbors.KNeighborsRegressor()
elif model_str == 'SVR':
return svm.SVR()
def __init__(self,
n_outputs,
regr='constant',
corr='squared_exponential',
storage_mode='full',
verbose=False,
theta0=1e-1):
self.gps = [
gaussian_process.GaussianProcess(regr=regr,
corr=corr,
storage_mode=storage_mode,
verbose=verbose,
theta0=theta0)
for i in range(n_outputs)
]
def gp_grade(trn_data, test_data, L1_FEATURES=False, seed=100):
gp = gaussian_process.GaussianProcess ( theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1,
nugget = 0.2)
def map(i):
if i ==107:
j = 0
elif i == 24:
j = 1
elif i == 32:
j = 2
elif i == 4:
j = 3
elif i == 73:
j = 4
elif i == 88:
j = 5
elif i == 98:
j = 7
return j
#L1=trn_data[2]
#test_L1 = test_data[2]
#L1_one_hot = np.zeros((L1.shape[0], 113), dtype=np.float32)
#test_L1_one_hot = np.zeros((test_L1.shape[0], 113), dtype=np.float32)
#for i in L1:
# L1_one_hot[int(i)]=1.0
#for i in test_L1:
# test_L1_one_hot[int(i)] = 1.0
if L1_FEATURES:
features = np.concatenate((trn_data[1], L1_one_hot), axis=1)
print features.shape
test_features = np.concatenate((test_data[1], test_L1_one_hot), axis=1)
gp.fit(features, trn_data[0])
predictions, variances = gp.predict (test_features, eval_MSE = True)
else:
gp.fit(trn_data[1], trn_data[0])
predictions, variances = gp.predict (test_data[1], eval_MSE = True)
variances = variances[:, np.newaxis]
return predictions, variances
def validate_gp_scikitlearn2():
D = 1
n_range = range(510, 9, -500)
n_heldout = 1000
fixed_x, fixed_y, z = parabola(n_heldout, D)
for i in xrange(len(n_range)):
n = n_range[i]
training_x, training_y, z = parabola(n, D)
y = training_y.flatten()
gp = gaussian_process.GaussianProcess(theta0=1e-2, thetaL=1e-4, thetaU=1e-1)
gp.fit(training_x, training_y)
y_pred, sigma2_pred = gp.predict(fixed_x, eval_MSE=True)
print("MSE: ", np.mean( (fixed_y.flatten()-y_pred) ** 2))
print("Sigma: ", sigma2_pred)
def gaussProcPred(xTrain, yTrain, xTest, covar):
xTrainAlter = []
for i in range(1, len(xTrain)):
tvec = xTrain[i - 1] + xTrain[i]
xTrainAlter.append(tvec)
xTestAlter = []
xTestAlter.append(xTrain[len(xTrain) - 1] + xTest[0])
for i in range(1, len(xTest)):
tvec = xTest[i - 1] + xTest[i]
xTestAlter.append(tvec)
clfr = gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1,
corr=covar)
clfr.fit(xTrainAlter, yTrain[1:])
return clfr.predict(xTestAlter, eval_MSE=True)[0]
def get_spatial_density(all_sites, dates, day_need):
X = np.empty((0, 3))
y = np.zeros((len(all_sites), 4))
for i, (key, info) in enumerate(all_sites.iteritems()):
utm_location = np.array([np.sqrt(info['utm'][0]**2 + info['utm'][1]**2), info['elev'], info['aspect']])
X = np.vstack((X, utm_location))
for j, temp_date in enumerate(dates):
y[i, j] = info['data']['density'][temp_date]
dem = gdal.Open('3m_data/Merced_500m_DEM.tif')
dem_georeference = dem.GetGeoTransform()
dem_raster = dem.ReadAsArray()
dem_xRasterSize = dem.RasterXSize
dem_yRasterSize = dem.RasterYSize
aspect_raster = gdal.Open('3m_data/Merced_500m_ASP.tif').ReadAsArray()
y_range = np.arange(dem_georeference[3] + 0.5 * dem_georeference[5],
dem_georeference[3] + (dem_xRasterSize + 0.5) * dem_georeference[5],
dem_georeference[5])
x_range = np.arange(dem_georeference[0] + 0.5 * dem_georeference[1],
dem_georeference[0] + (dem_yRasterSize + 0.5) * dem_georeference[1],
dem_georeference[1])
x_grid, y_grid = np.meshgrid(x_range, y_range)
x_predict = np.column_stack((np.column_stack((np.sqrt((x_grid.flatten()**2 + y_grid.flatten()**2)),
dem_raster.flatten())),
aspect_raster.flatten()))
x_predict_not_nan_idx = np.where(x_predict[:, 1] > 100.)
x_predict_new = x_predict[x_predict[:, 1] > 100.]
imp = Imputer()
y = imp.fit_transform(y)
gp = gaussian_process.GaussianProcess(theta0=1e-2, thetaL=1e-4,
thetaU=1., nugget=0.01, optimizer='Welch', random_start=100)
gp.fit(X, y[:, 2])
april_y_total = np.zeros(len(x_predict))
april_y_total[x_predict_not_nan_idx] = gp.predict(x_predict_new)
april_y_total = april_y_total.reshape((dem_yRasterSize, dem_xRasterSize))
gp.fit(X, y[:, 3])
may_y_total = np.zeros(len(x_predict))
may_y_total[x_predict_not_nan_idx] = gp.predict(x_predict_new)
may_y_total = may_y_total.reshape((dem_yRasterSize, dem_xRasterSize))
date_y_total = april_y_total + (may_y_total - april_y_total) / 30. * day_need
return date_y_total
def main():
# Create the dataset
x_train = np.atleast_2d(np.linspace(-2, 2, num=50)).T
y_train = f(x_train).ravel()
x_test = np.atleast_2d(np.linspace(-5, 5, 1000)).T
# Define the Regression Modell and fit it
gp = gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
gp.fit(x_train, y_train)
# Evaluate the result
y_pred, mse = gp.predict(x_test, eval_MSE=True)
print("MSE: %0.4f" % sum(mse))
print("max MSE: %0.4f" % max(mse))
plot_graph(x_test, x_train, y_pred, mse, "x^2")
def __init__(self, params, starts, goal, controller, state_dim=3):
self._params = params
self._controller = controller
self._starts = starts
self._goal = goal
# setup the graph structure and internal variables
self._g = StateGraph(state_dim=state_dim)
self._best_trajs = []
self._node_id = 0
self._max_conc = 1.0
self._max_es = 1.0
self._min_es = 0.0
self._gp = gaussian_process.GaussianProcess(corr='squared_exponential',
theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
def fit(X, y, regr_model, initial_theta, adaptive):
MACHINE_EPSILON = np.finfo(np.double).eps
#注意theta初始化范围，若theta最小值太小，可能造成估计方差太大
#将random_state调成10，从而提高使用cobyla对theta估计的准确性
if adaptive == True:
thetaL = 0.5 * initial_theta
thetaU = 2 * initial_theta
else:
thetaL = 1e-8 * np.ones([1, DIMESSION], dtype=float)
thetaU = 100 * np.ones([1, DIMESSION], dtype=float)
gp = gaussian_process.GaussianProcess(regr=regr_model,
normalize=True,
theta0=initial_theta,
thetaL=thetaL,
thetaU=thetaU,
nugget=50 * MACHINE_EPSILON,
random_start=25) # 不能使用Welch
gp.fit(X, y)
return gp
def fit_gaussian_process_baseline(self, frac=0.1, theta0=4.7, nugget=1.0, plot=True):
"""
Gaussian Process fit of baseline.
frac = fraction of baseline to use for fit
:return:
:rtype:
"""
from sklearn import gaussian_process
# Retrieve a reduced set of data
# (data up until first injection and x percent before every injection)
fit_indices, x, y = self._retrieve_fit_indices(frac)
# sklearn requires a 2d array, so make it pseudo 2d
full_x = numpy.atleast_2d(self.filter_period_end_time).T
x = numpy.atleast_2d(x).T
full_y = numpy.array(self.differential_power).T
y = numpy.array(y).T
gp = gaussian_process.GaussianProcess(regr='quadratic', corr='squared_exponential', theta0=theta0,
nugget=nugget,
random_start=100)
# Fit only based on the reduced set of the data
gp.fit(x, y)
y_pred, mean_squared_error = gp.predict(full_x, eval_MSE=True)
sigma = numpy.sqrt(mean_squared_error)
self.baseline_power = Quantity(y_pred, 'microcalories per second')
self.baseline_fit_data = {'x': full_x, 'y': y_pred, 'indices': fit_indices}
self.baseline_subtracted = self.differential_power - self.baseline_power
if plot:
self._plot_gaussian_baseline(full_x, full_y, sigma, x, y, y_pred)
self._plot_baseline_subtracted(full_x, self.baseline_subtracted)
def test_GaussianProcess_lt_017(self):
# http://scikit-learn.org/stable/modules/gaussian_process.html
X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T
y = np.sin(X).ravel()
df = pdml.ModelFrame(X, target=y)
g1 = df.gaussian_process.GaussianProcess(theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
g2 = gp.GaussianProcess(theta0=1e-2, thetaL=1e-4, thetaU=1e-1)
g1.fit(X, y)
g2.fit(X, y)
x = np.atleast_2d(np.linspace(0, 10, 1000)).T
tdf = pdml.ModelFrame(x)
y_result, sigma2_result = tdf.predict(g1, eval_MSE=True)
y_expected, sigma2_expected = g2.predict(x, eval_MSE=True)
self.assertIsInstance(y_result, pdml.ModelSeries)
tm.assert_index_equal(y_result.index, tdf.index)
self.assertIsInstance(sigma2_result, pdml.ModelSeries)
tm.assert_index_equal(sigma2_result.index, tdf.index)
self.assert_numpy_array_almost_equal(y_result.values, y_expected)
self.assert_numpy_array_almost_equal(sigma2_result.values,
sigma2_expected)
y_result = tdf.predict(g1)
y_expected = g2.predict(x)
self.assertIsInstance(y_result, pdml.ModelSeries)
tm.assert_index_equal(y_result.index, tdf.index)
self.assert_numpy_array_almost_equal(y_result, y_expected)
#pop=[]
#fit=[]
#results=[]
#counts=[]
dim = 66
X = np.concatenate(
(nprand.uniform(10.0, 30.0, [2, 6]), nprand.uniform(-0.3, 0.3, [2, 42]),
nprand.uniform(0.0, 30.0, [2, 1]), [[-3.5] * 4] * 2,
nprand.uniform(-30.0, 30.0, [2, 1]), nprand.uniform(
0.0, 0.3, [2, 6]), nprand.uniform(5.0, 20.0, [2, 6])),
axis=1)
maxprev = X[0]
y = np.asarray([f1(X[0]), f1(X[1])])
gp = gaussian_process.GaussianProcess(corr='linear',
theta0=1e-2,
thetaL=1e-4,
thetaU=1e-1)
gp.fit(X, y)
param = genfromtxt('param.csv', delimiter=',')
best = f1(param)
def findMin():
countFunc = 0
prec = 16
noVar = 66
upper = 5.12
lower = -5.12
noIndi = 20
windowSize = 5
fprev = [0.0] * windowSize
