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()