def ValidateAlgorithmSettings(self, request, context):
is_valid, message = OptimizerConfiguration.validate_algorithm_spec(
request.experiment.spec.algorithm)
if not is_valid:
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(message)
logger.error(message)
return api_pb2.ValidateAlgorithmSettingsReply()
def ValidateAlgorithmSettings(self, request, context):
algorithm_name = request.experiment.spec.algorithm.algorithm_name
if algorithm_name == "grid":
search_space = HyperParameterSearchSpace.convert(
request.experiment)
for param in search_space.params:
if param.type == DOUBLE:
if param.step == "" or param.step is None:
return self._set_validate_context_error(
context, "param {} step is nil".format(param.name))
return api_pb2.ValidateAlgorithmSettingsReply()
def ValidateAlgorithmSettings(self, request, context):
params = request.experiment.spec.parameter_specs.parameters
settings = request.experiment.spec.algorithm.algorithm_settings
setting_dict = {}
for setting in settings:
setting_dict[setting.name] = setting.value
if "r_l" not in setting_dict or "resource_name" not in setting_dict:
return self._set_validate_context_error(
context, "r_l and resource_name must be set.")
try:
rl = float(setting_dict["r_l"])
except:
return self._set_validate_context_error(
context, "r_l must be a positive float number.")
else:
if rl < 0:
return self._set_validate_context_error(
context, "r_l must be a positive float number.")
if "eta" in setting_dict:
eta = int(float(setting_dict["eta"]))
if eta <= 0:
eta = 3
else:
eta = 3
smax = int(math.log(rl) / math.log(eta))
max_parallel = int(math.ceil(eta**smax))
if request.experiment.spec.parallel_trial_count < max_parallel:
return self._set_validate_context_error(
context,
"parallelTrialCount must be not less than %d." % max_parallel)
valid_resourceName = False
for param in params:
if param.name == setting_dict["resource_name"]:
valid_resourceName = True
break
if not valid_resourceName:
return self._set_validate_context_error(
context,
"value of resource_name setting must be in parameters.")
return api_pb2.ValidateAlgorithmSettingsReply()
def ValidateAlgorithmSettings(self, request, context):
algorithm_name = request.experiment.spec.algorithm.algorithm_name
if algorithm_name == "grid":
search_space = HyperParameterSearchSpace.convert(
request.experiment)
available_space = {}
for param in search_space.params:
if param.type == INTEGER:
available_space[param.name] = range(
int(param.min),
int(param.max) + 1, int(param.step))
elif param.type == DOUBLE:
if param.step == "" or param.step is None:
return self._set_validate_context_error(
context,
"Param: {} step is nil".format(param.name))
double_list = np.arange(
float(param.min),
float(param.max) + float(param.step),
float(param.step))
if double_list[-1] > float(param.max):
double_list = double_list[:-1]
available_space[param.name] = double_list
elif param.type == CATEGORICAL or param.type == DISCRETE:
available_space[param.name] = param.list
num_combinations = len(
list(itertools.product(*available_space.values())))
max_trial_count = request.experiment.spec.max_trial_count
if max_trial_count > num_combinations:
return self._set_validate_context_error(
context,
"Max Trial Count: {} > all possible search space combinations: {}"
.format(max_trial_count, num_combinations))
return api_pb2.ValidateAlgorithmSettingsReply()
def ValidateAlgorithmSettings(self, request, context):
return api_pb2.ValidateAlgorithmSettingsReply()
def _set_validate_context_error(self, context, error_message):
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
logger.info(error_message)
return api_pb2.ValidateAlgorithmSettingsReply()
def ValidateAlgorithmSettings(self, request, context):
self.logger.info("Validate Algorithm Settings start")
graph_config = request.experiment.spec.nas_config.graph_config
# Validate GraphConfig
# Check InputSize
if not graph_config.input_sizes:
return self.SetValidateContextError(
context,
"Missing InputSizes in GraphConfig:\n{}".format(graph_config))
# Check OutputSize
if not graph_config.output_sizes:
return self.SetValidateContextError(
context,
"Missing OutputSizes in GraphConfig:\n{}".format(graph_config))
# Check NumLayers
if not graph_config.num_layers:
return self.SetValidateContextError(
context,
"Missing NumLayers in GraphConfig:\n{}".format(graph_config))
# Validate each operation
operations_list = list(
request.experiment.spec.nas_config.operations.operation)
for operation in operations_list:
# Check OperationType
if not operation.operation_type:
return self.SetValidateContextError(
context, "Missing operationType in Operation:\n{}".format(
operation))
# Check ParameterConfigs
if not operation.parameter_specs.parameters:
return self.SetValidateContextError(
context,
"Missing ParameterConfigs in Operation:\n{}".format(
operation))
# Validate each ParameterConfig in Operation
parameters_list = list(operation.parameter_specs.parameters)
for parameter in parameters_list:
# Check Name
if not parameter.name:
return self.SetValidateContextError(
context, "Missing Name in ParameterConfig:\n{}".format(
parameter))
# Check ParameterType
if not parameter.parameter_type:
return self.SetValidateContextError(
context,
"Missing ParameterType in ParameterConfig:\n{}".format(
parameter))
# Check List in Categorical or Discrete Type
if parameter.parameter_type == api_pb2.CATEGORICAL or parameter.parameter_type == api_pb2.DISCRETE:
if not parameter.feasible_space.list:
return self.SetValidateContextError(
context,
"Missing List in ParameterConfig.feasibleSpace:\n{}"
.format(parameter))
# Check Max, Min, Step in Int or Double Type
elif parameter.parameter_type == api_pb2.INT or parameter.parameter_type == api_pb2.DOUBLE:
if not parameter.feasible_space.min and not parameter.feasible_space.max:
return self.SetValidateContextError(
context,
"Missing Max and Min in ParameterConfig.feasibleSpace:\n{}"
.format(parameter))
if (parameter.parameter_type == api_pb2.DOUBLE and
(not parameter.feasible_space.step
or float(parameter.feasible_space.step) <= 0)):
return self.SetValidateContextError(
context,
"Step parameter should be > 0 in ParameterConfig.feasibleSpace:\n{}"
.format(parameter))
# Validate Algorithm Settings
settings_raw = request.experiment.spec.algorithm.algorithm_settings
for setting in settings_raw:
if setting.name in algorithmSettingsValidator.keys():
if setting.name in enableNoneSettingsList and setting.value == "None":
continue
setting_type = algorithmSettingsValidator[setting.name][0]
setting_range = algorithmSettingsValidator[setting.name][1]
try:
converted_value = setting_type(setting.value)
except Exception:
return self.SetValidateContextError(
context, "Algorithm Setting {} must be {} type".format(
setting.name, setting_type.__name__))
if setting_type == float:
if (converted_value <= setting_range[0]
or (setting_range[1] != 'inf'
and converted_value > setting_range[1])):
return self.SetValidateContextError(
context,
"Algorithm Setting {}: {} with {} type must be in range ({}, {}]"
.format(setting.name, converted_value,
setting_type.__name__, setting_range[0],
setting_range[1]))
elif converted_value < setting_range[0]:
return self.SetValidateContextError(
context,
"Algorithm Setting {}: {} with {} type must be in range [{}, {})"
.format(setting.name, converted_value,
setting_type.__name__, setting_range[0],
setting_range[1]))
else:
return self.SetValidateContextError(
context,
"Unknown Algorithm Setting name: {}".format(setting.name))
self.logger.info("All Experiment Settings are Valid")
return api_pb2.ValidateAlgorithmSettingsReply()
