From 658b733da1475388be65f51604ccbe454d569e4b Mon Sep 17 00:00:00 2001 From: YujiOshima Date: Mon, 19 Nov 2018 13:18:51 +0900 Subject: [PATCH 1/4] fix bayse optimization suggestion Signed-off-by: YujiOshima --- .../bayesianoptimization/requirements.txt | 2 + pkg/suggestion/bayesian_service.py | 252 ++++++++++-------- .../src/algorithm_manager.py | 59 +++- .../src/bayesian_optimization_algorithm.py | 22 +- .../src/global_optimizer/global_optimizer.py | 44 ++- 5 files changed, 239 insertions(+), 140 deletions(-) diff --git a/cmd/suggestion/bayesianoptimization/requirements.txt b/cmd/suggestion/bayesianoptimization/requirements.txt index c8f6744d657..8d2c9d4bda7 100644 --- a/cmd/suggestion/bayesianoptimization/requirements.txt +++ b/cmd/suggestion/bayesianoptimization/requirements.txt @@ -1,4 +1,6 @@ grpcio +duecredit +cloudpickle==0.5.6 numpy>=1.13.3 scikit-learn>=0.19.0 scipy>=0.19.1 diff --git a/pkg/suggestion/bayesian_service.py b/pkg/suggestion/bayesian_service.py index 0cc975421d9..1204b2015f1 100644 --- a/pkg/suggestion/bayesian_service.py +++ b/pkg/suggestion/bayesian_service.py @@ -8,10 +8,12 @@ from pkg.api.python import api_pb2_grpc from pkg.suggestion.bayesianoptimization.src.bayesian_optimization_algorithm import BOAlgorithm from pkg.suggestion.bayesianoptimization.src.algorithm_manager import AlgorithmManager +import logging +from logging import getLogger, StreamHandler, INFO, DEBUG class BayesianService(api_pb2_grpc.SuggestionServicer): - def __init__(self): + def __init__(self, logger=None): # { # study_id:[ # { @@ -21,134 +23,156 @@ def __init__(self): # } # ] # } - self.trial_hist = {} - # { - # study_id:{ - # N: - # } - # } - self.service_params = {} - - def GenerateTrials(self, request, context): - if request.study_id not in self.trial_hist.keys(): - self.trial_hist[request.study_id] = [] - X_train = [] - y_train = [] + self.manager_addr = "vizier-core" + self.manager_port = 6789 + if logger == None: + self.logger = getLogger(__name__) + FORMAT = '%(asctime)-15s StudyID %(studyid)s %(message)s' + logging.basicConfig(format=FORMAT) + handler = StreamHandler() + handler.setLevel(INFO) + self.logger.setLevel(INFO) + self.logger.addHandler(handler) + self.logger.propagate = False + else: + self.logger = logger - for x in request.completed_trials: - for trial in self.trial_hist[x.study_id]: - if trial["trial_id"] == x.trial_id: - trial["metric"] = x.objective_value - - for x in self.trial_hist[request.study_id]: - if x["metric"] is not None: - X_train.append(x["parameters"]) - y_train.append(x["metric"]) + def GetSuggestions(self, request, context): + service_params = self.parseParameters(request.param_id) + study_conf = self.getStudyConfig(request.study_id) + X_train, y_train = self.getEvalHistory(request.study_id, study_conf.objective_value_name, service_params["burn_in"]) algo_manager = AlgorithmManager( - study_id=request.study_id, - study_config=request.configs, - X_train=X_train, - y_train=y_train, + study_id = request.study_id, + study_config = study_conf, + X_train = X_train, + y_train = y_train, + logger = self.logger, ) lowerbound = np.array(algo_manager.lower_bound) upperbound = np.array(algo_manager.upper_bound) - # print("lowerbound", lowerbound) - # print("upperbound", upperbound) + self.logger.debug("lowerbound: %r", lowerbound, extra={"StudyID": request.study_id}) + self.logger.debug("upperbound: %r", upperbound, extra={"StudyID": request.study_id}) alg = BOAlgorithm( dim=algo_manager.dim, - N=int(self.service_params[request.study_id]["N"]), + N=int(service_params["N"]), lowerbound=lowerbound, upperbound=upperbound, X_train=algo_manager.X_train, y_train=algo_manager.y_train, - mode=self.service_params[request.study_id]["mode"], - trade_off=self.service_params[request.study_id]["trade_off"], + mode=service_params["mode"], + trade_off=service_params["trade_off"], # todo: support length_scale with array type - length_scale=self.service_params[request.study_id]["length_scale"], - noise=self.service_params[request.study_id]["noise"], - nu=self.service_params[request.study_id]["nu"], - kernel_type=self.service_params[request.study_id]["kernel_type"], - n_estimators=self.service_params[request.study_id]["n_estimators"], - max_features=self.service_params[request.study_id]["max_features"], - model_type=self.service_params[request.study_id]["model_type"], + length_scale=service_params["length_scale"], + noise=service_params["noise"], + nu=service_params["nu"], + kernel_type=service_params["kernel_type"], + n_estimators=service_params["n_estimators"], + max_features=service_params["max_features"], + model_type=service_params["model_type"], + logger=self.logger, ) - x_next = alg.get_suggestion().squeeze() - - # todo: maybe there is a better way to generate a trial_id - trial_id = ''.join(random.sample(string.ascii_letters + string.digits, 12)) - self.trial_hist[request.study_id].append(dict({ - "trial_id": trial_id, - "parameters": x_next, - "metric": None, - })) - # print(x_next) - - x_next = algo_manager.parse_x_next(x_next) - x_next = algo_manager.convert_to_dict(x_next) - trial = api_pb2.Trial( - trial_id=trial_id, - study_id=request.study_id, - parameter_set=[ - api_pb2.Parameter( - name=x["name"], - value=str(x["value"]), - parameter_type=x["type"], - ) for x in x_next - ], - status=api_pb2.PENDING, - eval_logs=[], + trials = [] + x_next_list = alg.get_suggestion(request.request_number) + for x_next in x_next_list: + x_next = x_next.squeeze() + self.logger.debug("xnext: %r ", x_next, extra={"StudyID": request.study_id}) + x_next = algo_manager.parse_x_next(x_next) + x_next = algo_manager.convert_to_dict(x_next) + trials.append(api_pb2.Trial( + study_id=request.study_id, + parameter_set=[ + api_pb2.Parameter( + name=x["name"], + value=str(x["value"]), + parameter_type=x["type"], + ) for x in x_next + ] + ) + ) + trials = self.registerTrials(trials) + return api_pb2.GetSuggestionsReply( + trials=trials ) - # print(self.trial_hist) + def getStudyConfig(self, studyID): + channel = grpc.beta.implementations.insecure_channel(self.manager_addr, self.manager_port) + with api_pb2.beta_create_Manager_stub(channel) as client: + gsrep = client.GetStudy(api_pb2.GetStudyRequest(study_id=studyID), 10) + return gsrep.study_config - return api_pb2.GenerateTrialsReply( - trials=[trial], - completed=False, - ) + def getEvalHistory(self, studyID, obj_name, burn_in): + worker_hist = [] + x_train = [] + y_train = [] + channel = grpc.beta.implementations.insecure_channel(self.manager_addr, self.manager_port) + with api_pb2.beta_create_Manager_stub(channel) as client: + gwfrep = client.GetWorkerFullInfo(api_pb2.GetWorkerFullInfoRequest(study_id=studyID, only_latest_log=True), 10) + worker_hist = gwfrep.worker_full_infos + #self.logger.debug("Eval Trials Log: %r", worker_hist, extra={"StudyID": studyID}) + for w in worker_hist: + if w.Worker.status == api_pb2.COMPLETED: + for ml in w.metrics_logs: + if ml.name == obj_name: + y_train.append(float(ml.values[-1].value)) + x_train.append(w.parameter_set) + break + self.logger.info("%d completed trials are found.", len(x_train), extra={"StudyID": studyID}) + if len(x_train) <= burn_in: + self.logger.info("Trials will be sampled until %d trials for burn-in are completed.", burn_in, extra={"StudyID": studyID}) + else: + self.logger.debug("Completed trials: %r", x_train, extra={"StudyID": studyID}) + + return x_train, y_train + + def registerTrials(self, trials): + channel = grpc.beta.implementations.insecure_channel(self.manager_addr, self.manager_port) + with api_pb2.beta_create_Manager_stub(channel) as client: + for i, t in enumerate(trials): + ctrep = client.CreateTrial(api_pb2.CreateTrialRequest(trial=t), 10) + trials[i].trial_id = ctrep.trial_id + return trials + + def parseParameters(self, paramID): + channel = grpc.beta.implementations.insecure_channel(self.manager_addr, self.manager_port) + params = [] + with api_pb2.beta_create_Manager_stub(channel) as client: + gsprep = client.GetSuggestionParameters(api_pb2.GetSuggestionParametersRequest(param_id=paramID), 10) + params = gsprep.suggestion_parameters + + parsed_service_params = { + "N": 100, + "model_type": "gp", + "max_features": "auto", + "length_scale": 0.5, + "noise": 0.0005, + "nu": 1.5, + "kernel_type": "matern", + "n_estimators": 50, + "mode": "pi", + "trade_off": 0.01, + "trial_hist": "", + "burn_in": 10, + } + modes = ["pi", "ei"] + model_types = ["gp", "rf"] + kernel_types = ["matern", "rbf"] + + for param in params: + if param.name in parsed_service_params.keys(): + if param.name == "length_scale" or param.name == "noise" or param.name == "nu" or param.name == "trade_off": + parsed_service_params[param.name] = float(param.value) + + elif param.name == "N" or param.name == "n_estimators" or param.name == "burn_in": + parsed_service_params[param.name] = int(param.value) + + elif param.name == "kernel_type" and param.value in kernel_types : + parsed_service_params[param.name] = param.value + + elif param.name == "mode" and param.value in modes: + parsed_service_params[param.name] = param.value + + elif param.name == "model_type" and param.value in model_types: + parsed_service_params[param.name] = param.value - def SetSuggestionParameters(self, request, context): - if request.study_id not in self.service_params.keys(): - self.service_params[request.study_id] = { - "N": None, - "length_scale": None, - "noise": None, - "nu": None, - "kernel_type": None, - "mode": None, - "trade_off": None, - "n_estimators": None, - "max_features": None, - "model_type": None, - } - for param in request.suggestion_parameters: - if param.name not in self.service_params[request.study_id].keys(): - context.set_code(grpc.StatusCode.UNKNOWN) - context.set_details("unknown suggestion parameter: "+param.name) - return api_pb2.SetSuggestionParametersReply() - if param.name == "length_scale" or param.name == "noise" or param.name == "nu" or param.name == "trade_off": - self.service_params[request.study_id][param.name] = float(param.value) - elif param.name == "N" or param.name == "n_estimators": - self.service_params[request.study_id][param.name] = int(param.value) - elif param.name == "kernel_type": - if param.value != "rbf" and param.value != "matern": - context.set_code(grpc.StatusCode.UNKNOWN) - context.set_details("unknown kernel type: " + param.value) - self.service_params[request.study_id][param.name] = param.value - elif param.name == "mode": - if param.value != "lcb" and param.value != "ei" and param.value != "pi": - context.set_code(grpc.StatusCode.UNKNOWN) - context.set_details("unknown acquisition mode: " + param.name) - self.service_params[request.study_id][param.name] = param.value - elif param.name == "model_type": - if param.value != "rf" and param.value != "gp": - context.set_code(grpc.StatusCode.UNKNOWN) - context.set_details("unknown model_type: " + param.name) - - return api_pb2.SetSuggestionParametersReply() - - def StopSuggestion(self, request, context): - if request.study_id in self.service_params.keys(): - del self.service_params[request.study_id] - del self.trial_hist[request.study_id] - return api_pb2.StopStudyReply() + return parsed_service_params diff --git a/pkg/suggestion/bayesianoptimization/src/algorithm_manager.py b/pkg/suggestion/bayesianoptimization/src/algorithm_manager.py index d7d5628403d..0898acf4c6c 100644 --- a/pkg/suggestion/bayesianoptimization/src/algorithm_manager.py +++ b/pkg/suggestion/bayesianoptimization/src/algorithm_manager.py @@ -3,7 +3,8 @@ import numpy as np from pkg.api.python import api_pb2 - +import logging +from logging import getLogger, StreamHandler, INFO, DEBUG def deal_with_discrete(feasible_values, current_value): """ function to embed the current values to the feasible discrete space""" @@ -11,18 +12,28 @@ def deal_with_discrete(feasible_values, current_value): diff = np.absolute(diff) return feasible_values[np.argmin(diff)] - def deal_with_categorical(feasible_values, one_hot_values): """ function to do the one hot encoding of the categorical values """ - index = np.argmax(one_hot_values) - return feasible_values[index] - + #index = np.argmax(one_hot_values) + index = one_hot_values.argmax() + return feasible_values[int(index)] class AlgorithmManager: """ class for the algorithm manager provide some helper functions """ - def __init__(self, study_id, study_config, X_train, y_train): + def __init__(self, study_id, study_config, X_train, y_train, logger=None): + if logger == None: + self.logger = getLogger(__name__) + FORMAT = '%(asctime)-15s StudyID %(studyid)s %(message)s' + logging.basicConfig(format=FORMAT) + handler = StreamHandler() + handler.setLevel(DEBUG) + self.logger.setLevel(DEBUG) + self.logger.addHandler(handler) + self.logger.propagate = False + else: + self.logger = logger self._study_id = study_id self._study_config = study_config self._goal = self._study_config.optimization_type @@ -34,18 +45,16 @@ def __init__(self, study_id, study_config, X_train, y_train): # record all the feasible values of discrete type variables self._discrete_info = [] self._categorical_info = [] + self._name_id = {} self._parse_config() - self._X_train = X_train + self._X_train = self._mapping_params(X_train) self.parse_X() self._y_train = y_train self._parse_metric() - # print(self._X_train) - # print(self._y_train) - @property def study_id(self): """ return the study id """ @@ -108,7 +117,8 @@ def y_train(self): def _parse_config(self): """ extract info from the study configuration """ - for param in self._study_config.parameter_configs.configs: + for i, param in enumerate(self._study_config.parameter_configs.configs): + self._name_id[param.name]=i self._types.append(param.parameter_type) self._names.append(param.name) if param.parameter_type == api_pb2.DOUBLE or param.parameter_type == api_pb2.INT: @@ -139,6 +149,29 @@ def _parse_config(self): })) self._dim += num_feasible + def _mapping_params(self, parameters_list): + if len(parameters_list) == 0: + return None + ret = [] + for parameters in parameters_list: + maplist = [np.zeros(1)]*len(self._names) + for p in parameters: + self.logger.debug("mapping: %r", p, extra={"StudyID": self._study_id}) + map_id = self._name_id[p.name] + if self._types[map_id] == api_pb2.DOUBLE or self._types[map_id] == api_pb2.INT or self._types[map_id] == api_pb2.DISCRETE: + maplist[map_id] = float(p.value) + elif self._types[map_id] == api_pb2.CATEGORICAL: + for ci in self._categorical_info: + if ci["name"] == p.name: + maplist[map_id] = np.zeros(ci["number"]) + for i, v in enumerate(ci["values"]): + if v == p.value: + maplist[map_id][i]=1 + break + self.logger.debug("mapped: %r", maplist, extra={"StudyID": self._study_id}) + ret.append(np.hstack(maplist)) + return ret + def _parse_metric(self): """ parse the metric to the dictionary """ if not self._y_train: @@ -150,14 +183,14 @@ def _parse_metric(self): y.append(float(metric)) else: y.append(-float(metric)) - + self.logger.debug("Ytrain: %r", y, extra={"StudyID": self._study_id}) self._y_train = np.array(y) def parse_X(self): if not self._X_train: self._X_train = None return - + self.logger.debug("Xtrain: %r", self._X_train, extra={"StudyID": self._study_id}) self._X_train = np.array(self._X_train) def parse_x_next(self, x_next): diff --git a/pkg/suggestion/bayesianoptimization/src/bayesian_optimization_algorithm.py b/pkg/suggestion/bayesianoptimization/src/bayesian_optimization_algorithm.py index 4bca66d1879..2709cc402e7 100644 --- a/pkg/suggestion/bayesianoptimization/src/bayesian_optimization_algorithm.py +++ b/pkg/suggestion/bayesianoptimization/src/bayesian_optimization_algorithm.py @@ -8,7 +8,7 @@ class BOAlgorithm: """ class for bayesian optimization """ def __init__(self, dim, N, lowerbound, upperbound, X_train, y_train, mode, trade_off, - length_scale, noise, nu, kernel_type, n_estimators, max_features, model_type): + length_scale, noise, nu, kernel_type, n_estimators, max_features, model_type, logger=None): # np.random.seed(0) self.dim = dim self.N = N or 100 @@ -21,7 +21,6 @@ def __init__(self, dim, N, lowerbound, upperbound, X_train, y_train, mode, trade self.scaler = MinMaxScaler() self.scaler.fit(np.append(self.lowerbound, self.upperbound, axis=0)) - self.x_next = None self.X_train = X_train self.y_train = y_train if self.y_train is None: @@ -47,15 +46,20 @@ def __init__(self, dim, N, lowerbound, upperbound, X_train, y_train, mode, trade n_estimators=n_estimators, max_features=max_features, model_type=model_type, + logger=logger, ) - def get_suggestion(self): + def get_suggestion(self, request_num): """ main function to provide suggestion """ + x_next_list = [] if self.X_train is None and self.y_train is None and self.current_optimal is None: # randomly pick a point as the first trial - self.x_next = np.random.uniform(self.lowerbound, self.upperbound, size=(1, self.dim)) - return self.x_next - _, self.x_next = self.optimizer.direct() - self.x_next = np.array(self.x_next).reshape(1, self.dim) - self.x_next = self.scaler.inverse_transform(self.x_next) - return self.x_next + for i in range(request_num): + x_next_list.append(np.random.uniform(self.lowerbound, self.upperbound, size=(1, self.dim))) + else: + _, x_next_list_que = self.optimizer.direct(request_num) + for xn in x_next_list_que: + x = np.array(xn).reshape(1, self.dim) + x = self.scaler.inverse_transform(x) + x_next_list.append(x) + return x_next_list diff --git a/pkg/suggestion/bayesianoptimization/src/global_optimizer/global_optimizer.py b/pkg/suggestion/bayesianoptimization/src/global_optimizer/global_optimizer.py index 4d7c7d6bd0e..3f4333e0ae7 100644 --- a/pkg/suggestion/bayesianoptimization/src/global_optimizer/global_optimizer.py +++ b/pkg/suggestion/bayesianoptimization/src/global_optimizer/global_optimizer.py @@ -3,8 +3,11 @@ """ import copy import numpy as np +from collections import deque from pkg.suggestion.bayesianoptimization.src.acquisition_func.acquisition_func import AcquisitionFunc +import logging +from logging import getLogger, StreamHandler, INFO, DEBUG class RectPack: @@ -70,7 +73,19 @@ class GlobalOptimizer: """ class for the global optimizer """ def __init__(self, N, l, u, scaler, X_train, y_train, current_optimal, mode, trade_off, length_scale, - noise, nu, kernel_type, n_estimators, max_features, model_type): + noise, nu, kernel_type, n_estimators, max_features, model_type, logger=None): + if logger == None: + self.logger = getLogger(__name__) + FORMAT = '%(asctime)-15s StudyID %(studyid)s %(message)s' + logging.basicConfig(format=FORMAT) + handler = StreamHandler() + handler.setLevel(INFO) + self.logger.setLevel(INFO) + self.logger.addHandler(handler) + self.logger.propagate = False + else: + self.logger = logger + self.N = N self.l = l self.u = u @@ -144,7 +159,7 @@ def potential_opt(self, f_min): # print(opt.point.fc) return opt_list2 - def direct(self): + def direct(self, request_num): """ main algorithm """ self.dim = self.l.shape[1] division_num = 0 @@ -185,9 +200,30 @@ def direct(self): if not bucket.array: index = self.buckets.index(bucket) del self.buckets[index] - ei_min.append(f_min) - return f_min, x_next + x_next_candidate = self.sample_buckets(request_num) + return f_min, x_next_candidate + + def sample_buckets(self, request_num): + self.logger.debug("In lne self.buckets: %r", len(self.buckets)) + bucket_index = [] + fc_sum = 0.0 + x_next_candidate = [] + for bucket in self.buckets: + for a in bucket.array: + self.logger.debug("fc: %r, %r", a.fc, a.center) + fc_sum -= a.fc + bucket_index.append([-a.fc, a.center]) + bucket_index = sorted(bucket_index, key=lambda x: x[0]) + for i in range(request_num): + sample = np.random.rand() + stick = 0.0 + for b in bucket_index: + stick += b[0]/fc_sum + if stick > sample: + x_next_candidate.append(b[1]) + break + return x_next_candidate def divide_rect(self, opt_rect, f_min, x_next, aq_func, scaler): """ divide the rectangular into smaller ones """ From ac5ece20d5486192d5db0624f15a46bd680ed139 Mon Sep 17 00:00:00 2001 From: YujiOshima Date: Mon, 19 Nov 2018 13:45:56 +0900 Subject: [PATCH 2/4] add bayseopt-example Signed-off-by: YujiOshima --- examples/bayseopt-example.yaml | 67 ++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 examples/bayseopt-example.yaml diff --git a/examples/bayseopt-example.yaml b/examples/bayseopt-example.yaml new file mode 100644 index 00000000000..0d582b3eb8e --- /dev/null +++ b/examples/bayseopt-example.yaml @@ -0,0 +1,67 @@ +apiVersion: "kubeflow.org/v1alpha1" +kind: StudyJob +metadata: + namespace: kubeflow + labels: + controller-tools.k8s.io: "1.0" + name: bayseopt-example +spec: + studyName: random-example + owner: crd + optimizationtype: maximize + objectivevaluename: Validation-accuracy + optimizationgoal: 0.99 + requestcount: 10 + metricsnames: + - accuracy + parameterconfigs: + - name: --lr + parametertype: double + feasible: + min: "0.01" + max: "0.03" + - name: --num-layers + parametertype: int + feasible: + min: "1" + max: "4" + - name: --optimizer + parametertype: categorical + feasible: + list: + - sgd + - adam + - ftrl + workerSpec: + goTemplate: + rawTemplate: |- + apiVersion: batch/v1 + kind: Job + metadata: + name: {{.WorkerID}} + namespace: kubeflow + spec: + template: + spec: + imagePullSecrets: + - name: gitlabregcred + containers: + - name: {{.WorkerID}} + image: katib/mxnet-mnist-example + command: + - "python" + - "/mxnet/example/image-classification/train_mnist.py" + - "--batch-size=32" + {{- with .HyperParameters}} + {{- range .}} + - "{{.Name}}={{.Value}}" + {{- end}} + {{- end}} + restartPolicy: Never + suggestionSpec: + suggestionAlgorithm: "bayesianoptimization" + suggestionParameters: + - + name: "burn_in" + value: "5" + requestNumber: 3 From df0adb51ec0a9061ef76568f0756fe656467402e Mon Sep 17 00:00:00 2001 From: YujiOshima Date: Mon, 19 Nov 2018 14:05:30 +0900 Subject: [PATCH 3/4] reset x_train in burn-in Signed-off-by: YujiOshima --- pkg/suggestion/bayesian_service.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkg/suggestion/bayesian_service.py b/pkg/suggestion/bayesian_service.py index 1204b2015f1..3a9ef89eb9f 100644 --- a/pkg/suggestion/bayesian_service.py +++ b/pkg/suggestion/bayesian_service.py @@ -119,6 +119,8 @@ def getEvalHistory(self, studyID, obj_name, burn_in): break self.logger.info("%d completed trials are found.", len(x_train), extra={"StudyID": studyID}) if len(x_train) <= burn_in: + x_train = [] + y_train = [] self.logger.info("Trials will be sampled until %d trials for burn-in are completed.", burn_in, extra={"StudyID": studyID}) else: self.logger.debug("Completed trials: %r", x_train, extra={"StudyID": studyID}) From ce2cb51ceed55d5671a0d2c4091cd0c79b9dd914 Mon Sep 17 00:00:00 2001 From: YujiOshima Date: Mon, 26 Nov 2018 19:01:08 +0900 Subject: [PATCH 4/4] validate parameters Signed-off-by: YujiOshima --- pkg/suggestion/bayesian_service.py | 37 ++++++++++++++++++++++-------- 1 file changed, 28 insertions(+), 9 deletions(-) diff --git a/pkg/suggestion/bayesian_service.py b/pkg/suggestion/bayesian_service.py index 3a9ef89eb9f..3a0e5750096 100644 --- a/pkg/suggestion/bayesian_service.py +++ b/pkg/suggestion/bayesian_service.py @@ -163,18 +163,37 @@ def parseParameters(self, paramID): for param in params: if param.name in parsed_service_params.keys(): if param.name == "length_scale" or param.name == "noise" or param.name == "nu" or param.name == "trade_off": - parsed_service_params[param.name] = float(param.value) + try: + float(param.value) + except ValueError: + self.logger.warning("Parameter must be float for %s: %s back to default value",param.name , param.value) + else: + parsed_service_params[param.name] = float(param.value) elif param.name == "N" or param.name == "n_estimators" or param.name == "burn_in": - parsed_service_params[param.name] = int(param.value) - - elif param.name == "kernel_type" and param.value in kernel_types : - parsed_service_params[param.name] = param.value - + try: + int(param.value) + except ValueError: + self.logger.warning("Parameter must be int for %s: %s back to default value",param.name , param.value) + else: + parsed_service_params[param.name] = int(param.value) + + elif param.name == "kernel_type": + if param.value != "rbf" and param.value != "matern": + parsed_service_params[param.name] = param.value + else: + self.logger.warning("Unknown Parameter for %s: %s back to default value",param.name , param.value) elif param.name == "mode" and param.value in modes: - parsed_service_params[param.name] = param.value - + if param.value != "lcb" and param.value != "ei" and param.value != "pi": + parsed_service_params[param.name] = param.value + else: + self.logger.warning("Unknown Parameter for %s: %s back to default value",param.name , param.value) elif param.name == "model_type" and param.value in model_types: - parsed_service_params[param.name] = param.value + if param.value != "rf" and param.value != "gp": + parsed_service_params[param.name] = param.value + else: + self.logger.warning("Unknown Parameter for %s: %s back to default value",param.name , param.value) + else: + self.logger.warning("Unknown Parameter name: %s ", param.name) return parsed_service_params