def model_config(self, model_name):
model = self.models[model_name]
if model is None:
return None
model_config = deepcopy(model)
config_keys = [
"name",
"type",
"path",
"target",
"prediction_key",
"features",
"training_features",
"hparams",
"data_partition_ratio",
"aggregates",
"training",
"evaluation",
"tags",
]
util.keep_dict_keys(model_config, config_keys)
for i, feature_name in enumerate(model_config["features"]):
model_config["features"][i] = self.feature_config(feature_name)
for i, feature_name in enumerate(model_config["training_features"]):
model_config["training_features"][i] = self.feature_config(
feature_name)
model_config["target"] = self.feature_config(model_config["target"])
aggregates_dict = {key: key for key in model_config["aggregates"]}
model_config["aggregates"] = self.populate_args(aggregates_dict)
return model_config
def constant_config(self, constant_name):
constant = self.constants[constant_name]
if constant is None:
return None
config = deepcopy(constant)
config_keys = ["name", "type", "tags"]
util.keep_dict_keys(config, config_keys)
return config
def raw_column_config(self, column_name):
raw_column = self.raw_columns[column_name]
if raw_column is None:
return None
config = deepcopy(raw_column)
config_keys = ["name", "type", "required", "min", "max", "values", "tags"]
util.keep_dict_keys(config, config_keys)
return config
def transformer_config(self, transformer_name):
transformer = self.transformers[transformer_name]
if transformer is None:
return None
config = deepcopy(transformer)
config_keys = ["name", "output_type", "inputs"]
util.keep_dict_keys(config, config_keys)
config["name"] = transformer_name # Use the fully qualified name (includes namespace)
return config
def aggregator_config(self, aggregator_name):
aggregator = self.aggregators[aggregator_name]
if aggregator is None:
return None
config = deepcopy(aggregator)
config_keys = ["name", "output_type", "inputs"]
util.keep_dict_keys(config, config_keys)
config["name"] = aggregator_name # Use the fully qualified name (includes namespace)
return config
def aggregate_config(self, aggregate_name):
aggregate = self.aggregates[aggregate_name]
if aggregate is None:
return None
config = deepcopy(aggregate)
config_keys = ["name", "type", "inputs", "aggregator", "tags"]
util.keep_dict_keys(config, config_keys)
config["inputs"] = self._expand_inputs_config(config["inputs"])
config["aggregator"] = self.aggregator_config(config["aggregator"])
return config
def transformed_column_config(self, column_name):
transformed_column = self.transformed_columns[column_name]
if transformed_column is None:
return None
config = deepcopy(transformed_column)
config_keys = ["name", "transformer", "inputs", "tags", "type"]
util.keep_dict_keys(config, config_keys)
config["inputs"] = self._expand_inputs_config(config["inputs"])
config["transformer"] = self.transformer_config(config["transformer"])
return config
def transformed_feature_config(self, feature_name):
transformed_feature = self.transformed_features[feature_name]
if transformed_feature is None:
return None
config = deepcopy(transformed_feature)
config_keys = ["name", "transformer", "inputs", "tags", "type"]
util.keep_dict_keys(config, config_keys)
config["inputs"] = self._expand_inputs_config(config["inputs"])
config["transformer"] = self.transformer_config(config["transformer"])
return config
def raw_feature_config(self, feature_name):
raw_feature = self.raw_features[feature_name]
if raw_feature is None:
return None
config = deepcopy(raw_feature)
config_keys = [
"name", "type", "required", "min", "max", "values", "tags"
]
util.keep_dict_keys(config, config_keys)
return config
def model_config(self, model_name):
model = self.models[model_name]
if model is None:
return None
estimator = self.estimators[model["estimator"]]
target_column = self.columns[util.get_resource_ref(model["target_column"])]
if estimator.get("target_column") is not None:
target_col_type = self.get_inferred_column_type(target_column["name"])
if target_col_type not in estimator["target_column"]:
raise UserException(
"model " + model_name,
"target_column",
target_column["name"],
"unsupported type (expected type {}, got type {})".format(
util.data_type_str(estimator["target_column"]),
util.data_type_str(target_col_type),
),
)
model_config = deepcopy(model)
config_keys = [
"name",
"estimator"
"estimator_path"
"target_column"
"input"
"training_input"
"hparams"
"prediction_key"
"data_partition_ratio"
"training"
"evaluation"
"tags",
]
util.keep_dict_keys(model_config, config_keys)
model_config["target_column"] = target_column["name"]
model_config["input"] = self.populate_values(
model["input"], estimator["input"], preserve_column_refs=False
)
if model.get("training_input") is not None:
model_config["training_input"] = self.populate_values(
model["training_input"], estimator["training_input"], preserve_column_refs=False
)
if model.get("hparams") is not None:
model_config["hparams"] = self.populate_values(
model["hparams"], estimator["hparams"], preserve_column_refs=False
)
return model_config
