def gp_sklearn_interpolator(x, y, res=1000):
kernel = DotProduct(10.0, (1e-2, 1e2)) * RationalQuadratic(0.1)
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=9)
gp.fit(x.reshape(-1, 1), (y - x).reshape(-1, 1))
x_pred = np.linspace(0, 1, 1000)
y_pred, sigma = gp.predict(x_pred[:, np.newaxis], return_std=True)
y_pred = y_pred.ravel() + x_pred
return x_pred, y_pred
def test_gpr_correct_error_message():
X = np.arange(12).reshape(6, -1)
y = np.ones(6)
kernel = DotProduct()
gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.0)
message = ("The kernel, %s, is not returning a "
"positive definite matrix. Try gradually increasing "
"the 'alpha' parameter of your "
"GaussianProcessRegressor estimator." % kernel)
with pytest.raises(np.linalg.LinAlgError, match=re.escape(message)):
gpr.fit(X, y)
def update_cov_fcns(self,
rbf_ub=2000.0,
matern_ub=4000.0,
dotProduct_ub=1000.0):
self.cov = sum([
0.5 * RBF(length_scale=100.0, length_scale_bounds=(1e-1, rbf_ub)),
0.5 *
Matern(length_scale=100.0, length_scale_bounds=(1e-1, matern_ub)),
1.0 *
DotProduct(sigma_0=100.0, sigma_0_bounds=(1e-2, dotProduct_ub)),
1.0 * WhiteKernel()
])
def test_partial_float64(self):
data = load_boston()
X, y = data.data, data.target
X_train, X_test, y_train, _ = train_test_split(X, y)
gau = GaussianProcessRegressor(alpha=10, kernel=DotProduct())
gau.fit(X_train, y_train)
onnxgau48 = to_onnx(gau, X_train.astype(numpy.float32), dtype=numpy.float32,
options={GaussianProcessRegressor: {'float64': True}})
oinf48 = OnnxInference(onnxgau48, runtime="python")
out = oinf48.run({'X': X_test.astype(numpy.float32)})
y = out['GPmean']
self.assertEqual(y.dtype, numpy.float32)
def create_classifiers() -> List:
kernel = DotProduct() + WhiteKernel()
return [KNeighborsClassifier(3),
SVC(kernel='poly', gamma='scale', probability=True),
SVC(gamma=2, C=1, probability=True),
GaussianProcessClassifier(kernel=Matern(nu=2.5)),
GaussianProcessClassifier(kernel=kernel),
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1, min_samples_leaf=5),
RandomForestClassifier(max_depth=10, n_estimators=10, max_features=1, ),
GaussianNB(),
LinearDiscriminantAnalysis(solver='eigen', shrinkage='auto', tol=0.0001),
QuadraticDiscriminantAnalysis()]
def plot_prediction_color(filename, material):
df = pd.read_json(filename)
df_filtered = df.loc[df['breeder_material_name'] == material]
for k in range(
1, 100
): #improvement of the dataset we remove the worst tbr values and we had a better enrichment configuration to replace it
X = list(df_filtered['enrichment_value'])
y = list(df_filtered['value'])
kernel = DotProduct() + WhiteKernel()
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0).fit(X, y)
gpr.score(X, y)
row_max_tbr = df_filtered.loc[df_filtered['value'].idxmax()]
row_min_tbr = df_filtered.loc[df_filtered['value'].idxmin()]
bounds = [(0, 1), (0, 1)]
GP = GpOptimiser(X, y, bounds=bounds)
new_enrichment_value = list(GP.search_for_maximum())
X.remove(row_min_tbr['enrichment_value'])
y.remove(row_min_tbr['value'])
print('new enrichment fraction', new_enrichment_value)
append_to_json = find_tbr_dict(new_enrichment_value, material, True,
500000)
#adjust the number of batches with the experiment
X.append(new_enrichment_value)
y.append(append_to_json['value'])
with open(
'results_new_neutron_source/added_' + str(k) +
'_result_2_layers_halton_first_wall_neural_network.json',
'w') as file_object:
json.dump([append_to_json], file_object, indent=2)
print('file created')
df_append = pd.read_json(
'results_new_neutron_source/added_' + str(k) +
'_result_2_layers_halton_first_wall_neural_network.json')
df_filtered = df_filtered.append(df_append,
ignore_index=True,
sort=True)
idx = df_filtered.index[df_filtered['value'] == row_min_tbr['value']]
df_filtered = df_filtered.drop(idx[0])
TBR = y
print(
'The max TBR for ' + str(len(X[0])) + ' layers and ' + str(material) +
' is', max(TBR))
def error_rate(self):
if self.kernel == "RBF":
gpc = GaussianProcessClassifier(kernel=1.0 * RBF([1.0])).fit(self.x_train, self.y_train)
elif self.kernel == "DP":
gpc = GaussianProcessClassifier(kernel=DotProduct(sigma_0=1.0)).fit(self.x_train, self.y_train)
else:
print("Error")
yp_train = gpc.predict(self.x_train)
train_error_rate = np.mean(np.not_equal(yp_train, self.y_train))
yp_test = gpc.predict(self.x_test)
test_error_rate = np.mean(np.not_equal(yp_test, self.y_test))
return train_error_rate, test_error_rate
def gaussian_proces_regressor(data):
predicted_speedups = np.zeros((data.shape[0]))
for row_idx in range(0, data.shape[0]):
training_x = np.concatenate(
(data[0:row_idx, 1:-1], data[row_idx + 1:, 1:-1]), axis=0)
training_y = np.concatenate(
(data[0:row_idx, -1], data[row_idx + 1:, -1]), axis=0)
kernel = DotProduct() + WhiteKernel()
reg = GaussianProcessRegressor(kernel=kernel, random_state=0).fit(
training_x, training_y)
test_x = data[row_idx:row_idx + 1, 1:-1]
predicted_speedups[row_idx] = reg.predict(test_x)
return predicted_speedups
def test_export_sklearn_kernel_dot_product(self):
def kernel_call_ynone(X, sigma_0=2.):
t_sigma_0 = py_make_float_array(py_pow(sigma_0, 2))
K = X @ numpy.transpose(X, axes=[1, 0]) + t_sigma_0
return K
x = numpy.array([[1, 2], [3, 4], [5, 6]], dtype=float)
kernel = DotProduct(sigma_0=2.)
exp = kernel(x, None)
got = kernel_call_ynone(x, sigma_0=2.)
self.assertEqualArray(exp, got)
context = {
'numpy.inner': numpy.inner,
'numpy.transpose': numpy.transpose,
'py_pow': py_pow,
'py_make_float_array': py_make_float_array
}
from skl2onnx.algebra.onnx_ops import ( # pylint: disable=E0611,E0401
OnnxTranspose, OnnxMatMul, OnnxAdd, OnnxPow)
ctx = {
'OnnxPow': OnnxPow,
'OnnxAdd': OnnxAdd,
'OnnxIdentity': OnnxIdentity,
'OnnxTranspose': OnnxTranspose,
'OnnxMatMul': OnnxMatMul,
'py_make_float_array': py_make_float_array,
'py_pow': py_pow
}
fct = translate_fct2onnx(kernel_call_ynone,
context=context,
cpl=True,
context_cpl=ctx,
output_names=['Z'])
r = fct('X', op_version=get_opset_number_from_onnx())
self.assertIsInstance(r, OnnxIdentity)
inputs = {'X': x.astype(numpy.float32)}
onnx_g = r.to_onnx(inputs)
oinf = OnnxInference(onnx_g)
res = oinf.run(inputs)
self.assertEqualArray(exp, res['Z'])
exp = kernel(x.T, None)
got = kernel_call_ynone(x.T)
self.assertEqualArray(exp, got)
inputs = {'X': x.T.astype(numpy.float32)}
res = oinf.run(inputs)
self.assertEqualArray(exp, res['Z'])
def get_phi(self):
kernel = 1.0*RBF(length_scale=1.0) + WhiteKernel(noise_level=1.0)
kernel += 1.0*DotProduct(sigma_0=1.0) + 1.0*Matern(length_scale=1.0)
estimator = GaussianProcessRegressor(kernel=kernel,
n_restarts_optimizer=8, alpha=0)
phi = []
score_lib = {}
for n, i in enumerate(self.features):
print('Working on {}'.format(i))
score_comb = []
f = [j for j in self.features if j != i]
for j in range(0, len(f)+1):
score = []
for k in combinations(f, j):
if j != 0:
key = '_'.join(sorted(list(k)))
if key in score_lib:
score_exclude = score_lib[key]
print('Getting data from lib.')
else:
X = self.df[list(k)]
y = self.df[self.target]
estimator.fit(X, y)
score_exclude = r2_score(estimator.predict(X), y)
score_lib[key] = score_exclude
msg = 'Adding {} with score {} to the score lib'
print(msg.format(key, score_exclude))
else:
score_exclude = 0
key = '_'.join(sorted(list(k)+[i]))
if key in score_lib:
score_include = score_lib[key]
print('Getting data from lib.')
else:
X = self.df[list(k) + [i]]
y = self.df[self.target]
estimator.fit(X, y)
score_include = r2_score(estimator.predict(X), y)
score_lib[key] = score_include
msg = 'Adding {} with score {} to the score lib'
print(msg.format(key, score_include))
score.append(score_include - score_exclude)
score_comb.append(sum(score)/len(score))
phi.append(sum(score_comb)/len(score_comb))
phi_percentage = [i/sum(phi)*100 for i in phi]
return {'features': self.features,
'phi': phi,
'phi_percentage': phi_percentage,
'score_lib': score_lib}
def __init__(self,
ml_algs=[
'LR', 'GPR', 'MLP', 'DL', 'SVR', 'RFR', 'DTR', 'GBR'
]):
super().__init__()
self.regressors = []
for alg in ml_algs:
# if alg == 'DL':
# self.regressors.append(DeepLearningRegressor(type='custom'))
if alg == 'BRR':
self.regressors.append(linear_model.BayesianRidge())
elif alg == 'RFR':
self.regressors.append(RandomForestRegressor(n_estimators=100))
elif alg == 'DTR':
self.regressors.append(DecisionTreeRegressor())
elif alg == 'GBR':
self.regressors.append(GradientBoostingRegressor())
elif alg == 'LR':
self.regressors.append(LinearRegression())
elif alg == 'GPR':
self.regressors.append(
GaussianProcessRegressor(kernel=DotProduct() +
WhiteKernel(),
random_state=0))
elif alg == 'SVR':
self.regressors.append(
SVR(kernel='rbf', C=100, gamma=0.1, epsilon=.1))
elif alg == 'MLP':
self.regressors.append(
MLPRegressor(hidden_layer_sizes=(100, ),
activation='relu',
solver='adam',
alpha=0.001,
batch_size='auto',
learning_rate='constant',
learning_rate_init=0.01,
power_t=0.5,
max_iter=1000,
shuffle=True,
random_state=0,
tol=0.0001,
verbose=False,
warm_start=False,
momentum=0.9,
nesterovs_momentum=True,
early_stopping=False,
validation_fraction=0.1,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08))
def fit(self, x, y):
y = y["y_ph"]
# define the GP kernel
kernel = DotProduct(sigma_0=self.sigma_0)
# kernel = RBF(length_scale=1e2)
# define the model
self.model = GaussianProcessRegressor(kernel=kernel,
alpha=self.alpha,
random_state=misc.seed)
# fit the model
self.model.fit(x, y)
def regressor(X_train, Y_train):
kernel = 1.0 * RBF(length_scale=0.01, length_scale_bounds=(1e-1, 1e2)) + (
DotProduct()**3) * WhiteKernel(noise_level=2.e-8,
noise_level_bounds=(1e-10, 1e-1))
gp = GaussianProcessRegressor(kernel=kernel,
alpha=0.,
n_restarts_optimizer=15).fit(
X_train, Y_train)
print "kernel init: ", kernel
print "kernel init params: ", kernel.theta
print "kenel optimum: ", gp.kernel_
print "opt kernel params: ", gp.kernel_.theta
print "LML (opt): ", gp.log_marginal_likelihood()
return gp
def __init__(self, params=None, limit=None, model=None):
""" Init """
if model is None:
kernel = PairwiseKernel(
metric='laplacian') * DotProduct() + WhiteKernel(
noise_level=5.0)
self.model = GaussianProcessClassifier(kernel=kernel, n_jobs=-1)
else:
self.fitted = True
self.model = model
if limit is not None:
self.limit = limit
def gpr_train2(train_bids, test_bid):
test_data, train_X, train_Y, test_X, test_Y = get_data2(
train_bids, test_bid)
kernel = RBF() + Matern() + RationalQuadratic() + DotProduct()
reg = GaussianProcessRegressor(kernel=kernel,
n_restarts_optimizer=10,
alpha=0.1)
reg.fit(train_X, train_Y)
output, err = reg.predict(test_X, return_std=True)
rmse = np.sqrt(metrics.mean_squared_error(test_Y, output))
print(test_bid + ": " + str(rmse))
X = np.arange(test_data.shape[0])
up, down = output * (1 + 1.96 * err), output * (1 - 1.96 * err)
return X, test_Y, output, rmse, up, down
def str2ker(str):
k1 = C(1.0) * RBF(length_scale=1)
k2 = C(1.0) * RationalQuadratic(length_scale=1)
k4 = DotProduct(sigma_0=1)
k3 = C(1.0) * ExpSineSquared(length_scale=1, periodicity=1)
k5 = WhiteKernel(1.0)
map = {"s": k1, "r": k2, "p": k3, "l": k4}
# if basic kernel
if len(str) == 1:
ker = map[str]
else:
# if composite kernel
ker = []
factor = map[str[0]]
op = str[1]
for i in range(2, len(str), 2):
# if the operator is *, use @ covProd to continue costructing the
# factor
if op == '*':
factor = factor * map[str[i]]
# the end?
if i == len(str) - 1:
if not ker:
ker = factor
else:
ker = ker + factor
else:
op = str[i + 1]
# if the oprator is +, combine current factor with ker then form a
# new factor
else:
if not ker:
ker = factor
else:
ker = ker + factor
factor = map[str[i]]
# % the end?
if i == len(str) - 1:
ker = ker + factor
else:
op = str[i + 1]
ker = ker + k5
return ker
def __init__(self, params=None, model=None, limit=.5, noise_level=5):
""" Init """
logging.info('Using scikit GPCLassifier')
if model is None:
kernel = PairwiseKernel(
metric='laplacian') * DotProduct() + WhiteKernel(
noise_level=noise_level)
self.model = GaussianProcessClassifier(kernel=kernel, n_jobs=-1)
else:
self.fitted = True
self.model = model
if limit is not None:
self.limit = limit
def fig_dotprod_kernel(only_trace: bool = True):
from sklearn.gaussian_process.kernels import DotProduct
kernel = DotProduct()
x = np.linspace(-1, 1, 100)
x_exp = np.expand_dims(x, axis=1)
surf_data = kernel(x_exp, x_exp)
trace = go.Surface(x=x, y=x, z=surf_data, showscale=False)
if only_trace:
return trace
else:
fig.update_layout(scene=dict(xaxis_title='xi',
yaxis_title='xj',
zaxis_title='Linear Kernel Value'),
margin=dict(r=10, b=10, l=10, t=10))
return fig
def main():
dg = DatasetGenerater(X_MIN, X_MAX, N_DATA, NOISE_AMP, BASE_FUNC, is_noisy=True)
X, Y = dg.generate_dateset()
train_data_index = np.random.randint(0, N_DATA, int(N_DATA * 0.1))
X_train, Y_train = X[train_data_index], Y[train_data_index]
X, X_train = X.reshape((-1, 1)), X_train.reshape((-1, 1))
kernels = {
"Gaussian Kernel": 0.594 ** 2 * RBF(length_scale=0.279),
"Product": DotProduct(),
}
for name, kernel in kernels.items():
model_gpr = GaussianProcessRegressor(kernel=kernel)
reg = model_gpr.fit(X_train, Y_train)
Y_pred, Y_std = reg.predict(X, return_std=True)
Visualizer.visualize_gaussian_process(X, Y, Y_pred, Y_std, title=name)
def fit(self):
# get training data
x, y, t = self._str2dataset("train")
# define the GP kernel
kernel = DotProduct(sigma_0=self.params["sigma_0"],
sigma_0_bounds=(self.params["sigma_0"],self.params["sigma_0"]))
# define the model
self.model = GaussianProcessRegressor(kernel=kernel,
alpha=self.params["alpha"],
random_state=cs.seed
)
# fit the model
self.model.fit(x, y)
def initGPs(self):
for c in range(0, self.ncampaigns):
#C(1.0, (1e-3, 1e3))
#l= np.array([200,200])
#kernel = C(1, (1e-3, 1e1))*RBF(l, ((100, 300),(100,300)))
l = np.array([1.0, 1.0])
kernel = C(1.0, (1e-3, 1e3)) * RBF(l, ((1e-3, 1e3), (1e-3, 1e3)))
kernel = kernel * DotProduct(1.0)
#l=1.0
#kernel = C(1.0, (1e-3, 1e3)) * RBF(l, (1e-3, 1e3))
alpha = 200
self.gps.append(
GaussianProcessRegressor(kernel=kernel,
alpha=alpha,
n_restarts_optimizer=10,
normalize_y=True))
def __init__(self):
# define dimensionality
self.ndim = 2
# kernels
# 1.0 * ExpSineSquared(length_scale=1.0, periodicity=3.0,
# length_scale_bounds=(0.1, 10.0),
# periodicity_bounds=(1.0, 10.0)),
self.kernels = [
1.0 * RBF(length_scale=8.0, length_scale_bounds=(1e-1, 10.0)),
1.0 * RationalQuadratic(length_scale=1.0, alpha=0.1),
ConstantKernel(0.1, (0.01, 10.0)) *
(DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0))**2), 1.0 *
Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=1.5)
]
# range action
self.min_action = -10 * np.ones(self.ndim)
self.max_action = 10 * np.ones(self.ndim)
# range observation - dimensionality
self.low_state = np.append([-30.0, -30.0], self.min_action)
self.high_state = np.append([30.0, 30.0], self.max_action)
# range state - dimensionality
self.low_state_p = -6 * np.ones(self.ndim)
self.high_state_p = 6 * np.ones(self.ndim)
# meshgrid of states
#self.x_ = np.arange(self.low_state_p[0]-1,self.high_state_p[0]+1,1)
self.x_ = np.arange(-8, 8, 1)
self.grid = np.array(np.meshgrid(self.x_, self.x_)).T.reshape(-1, 2)
print(self.grid.shape)
#self.grid = self.grid.reshape(-1,1)
#print(self.grid.shape)
# boxes
self.action_space = spaces.Box(low=self.min_action,
high=self.max_action)
self.observation_space = spaces.Box(low=self.low_state,
high=self.high_state)
self.hyper_space = spaces.Box(low=self.low_state_p,
high=self.high_state_p)
# init
self.obs = self.observation_space.sample()
self.state = self.hyper_space.sample()
self.prev_unscaled = 0
self.gp = 0
# init thread
self.seed()
self.reset()
def train_gpr_model(TRAIN):
""" Train Gaussian Process Regression model
Params:
-------
TRAIN: Pandas dataframe
training set; last column is label
Yields:
-------
gpr: Gaussian Process Regression model
"""
train_dat = TRAIN.iloc[:, :-1]
train_gs = TRAIN.iloc[:, -1]
kernel = DotProduct() + WhiteKernel()
gpr = GaussianProcessRegressor(kernel=kernel,
random_state=0).fit(train_dat, train_gs)
return gpr
def __init__(self,
args1={
'kernel': 'rbf',
'probability': True
},
args2={
'kernel': DotProduct(),
'probability': True
},
verbose=False):
"""
...
"""
self.model1 = SVC(**args1)
self.model2 = SVC(**args2)
self.verbose = verbose
def test_sum():
# define rbf and dot product custom kernels, and set hyperparameters
custom_rbf_kernel = generate_kernel(rbf, rbf_grad)
custom_dot_prod_kernel = generate_kernel(dot_prod, dot_prod_grad)
sum_custom_kernel = Sum(custom_dot_prod_kernel, custom_rbf_kernel)
model = GaussianProcessRegressor(kernel=sum_custom_kernel, random_state=0)
model.fit(X_train, Y_train)
preds1 = model.predict(X_test)
sum_kernel = Sum(DotProduct(), RBF())
model = GaussianProcessRegressor(kernel=sum_kernel, random_state=0)
model.fit(X_train, Y_train)
preds2 = model.predict(X_test)
assert (np.all(np.isclose(preds1, preds2)))
def model_GaussianProcess(option):
option.report_model = 'GaussianProcess'
option.lamNum = 0
sign = -1
kernel = None
dim = np.asarray(option.X).shape[1]
if option.mode == '1':
while (sign != 0):
choice = float(
input(
'Choose kernel: 1. RBF 2. ExpSineSquared 3. RationalQuadratic 4. WhiteKernel 5. Dotproduct 6. ConstantKernel 7. Matern:'
))
if (choice == 1):
nextkernel = RBF(5 * np.ones(dim),
length_scale_bounds=(1e-3, 1e3))
elif (choice == 2):
nextkernel = ExpSineSquared(length_scale=1.3, periodicity=1)
elif (choice == 3):
nextkernel = RationalQuadratic(alpha=0.7, length_scale=1.2)
elif (choice == 4):
nextkernel = WhiteKernel(noise_level=1)
elif (choice == 5):
nextkernel = DotProduct(sigma_0=1)
elif (choice == 6):
nextkernel = ConstantKernel()
elif (choice == 7):
nextkernel = Matern(length_scale=1.0, nu=1.5)
else:
print("Bad input.")
if (sign == 1):
kernel = kernel + nextkernel
elif (sign == 2):
kernel = kernel * nextkernel
elif (sign == 3):
kernel = kernel**nextkernel
elif (sign == -1):
kernel = nextkernel
else:
print('Bad input')
sign = float(input('Choose sign: 1.add 2.multiply 3.exp 0.done:'))
else:
kernel = 1.0 * RBF(1.0)
print('Your kernel:')
print(kernel)
option.kernel = kernel
def test_kernel_ker2_dotproduct(self):
ker = DotProduct(sigma_0=2.)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType())],
outputs=[('Y', FloatTensorType())],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
x = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
res = sess.run(None, {'X': x})
m1 = res[0]
m2 = ker(x)
assert_almost_equal(m1, m2, decimal=5)
res = sess.run(None, {'X': Xtest_.astype(np.float32)})
m1 = res[0]
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=2)
def get_nonlinear_model(params):
"""output a nonlinear GPR model
params: dict, containing details on PCA if required
returns:
model: sklearn estimator
"""
kernel = 1 * DotProduct(sigma_0=1e-5, sigma_0_bounds='fixed') + RBF(length_scale=10.0, length_scale_bounds=(1.0, 1000.0)) + WhiteKernel(10.0, noise_level_bounds=(1.0,1000))
ss = StandardScaler()
gpr = GaussianProcessRegressor(kernel=kernel, alpha=0, normalize_y=True, n_restarts_optimizer=50)
if params['pca']:
pca = PCA(n_components=params['pca_comps'], whiten=True)
nonlinear_model = Pipeline(steps=(['scale', ss], ['pca', pca], ['model', gpr])) # pipeline
else:
nonlinear_model = Pipeline(steps=(['scale', ss], ['model', gpr]))
return clone(nonlinear_model)
def train_concat_model(target_wl, observed_data, primer_data, closest_wl):
def remove_duplicate_knobs(xd, yd):
unique_knobs = [tuple(xd[i, :]) for i in range(xd.shape[0])]
idxs_to_remove = []
for i in range(xd.shape[0]):
following_knobs = [
tuple(xd[j, :]) for j in range(i + 1, xd.shape[0])
]
if tuple(xd[i]) in following_knobs:
idxs_to_remove.append(i)
xd = np.delete(xd, idxs_to_remove, 0)
yd = np.delete(yd, idxs_to_remove, 0)
return xd, yd
closest_data = observed_data.prune_columns(
['workload id'] + observed_data.get_tuning_knob_headers() +
['latency']).get_specific_workload(closest_wl).get_dataframe()
target_data = primer_data.prune_columns(
['workload id'] + primer_data.get_tuning_knob_headers() +
['latency']).get_specific_workload(target_wl).get_dataframe()
concat_data = pd.concat([closest_data, target_data],
ignore_index=True).values
# concat_data = target_data.values
X, y = remove_duplicate_knobs(concat_data[:, 1:-1], concat_data[:, -1])
alpha = np.array([7e8 for i in range(X.shape[0] - 5)] +
[1e1 for i in range(5)])
kernel = ConstantKernel(0.01, (0.01, 0.5)) * (DotProduct(
sigma_0=2.0, sigma_0_bounds=(0.01, 30.0))**2)
model = GaussianProcessRegressor(kernel=kernel,
normalize_y=True,
alpha=alpha,
n_restarts_optimizer=15)
ss_x = StandardScaler()
ss_y = StandardScaler()
if use_scaling:
binary_knobs = X[:, 6]
X = ss_x.fit_transform(X)
X[:, 6] = binary_knobs
# y = ss_y.fit_transform(np.expand_dims(y,1))
model.fit(X, y)
return model, ss_x, ss_y
def _kernels(self, i):
kernels = [
1.0 * RBF(length_scale=self.length_scale,
length_scale_bounds=self.length_scale_bounds),
1.0 * RationalQuadratic(length_scale=self.length_scale,
alpha=self.alpha),
1.0 * ExpSineSquared(length_scale=self.length_scale,
periodicity=self.periodicity,
length_scale_bounds=self.length_scale_bounds,
periodicity_bounds=self.periodicity_bounds),
ConstantKernel(constant_value=self.constant_value,
constant_value_bounds=self.constant_value_bounds) *
(DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0))**2),
1.0 * Matern(length_scale=self.length_scale,
length_scale_bounds=self.length_scale_bounds,
nu=self.nu)
]
return kernels[i]