def metric_summary_to_proto(
metric_summary: MetricSummary) -> MetricSummaryProto:
return MetricSummaryProto(
uuid=metric_summary.uuid,
metric_id=int64Value(metric_summary.metric_id),
metric_key=stringValue(metric_summary.metric_key),
metric_value=stringValue(metric_summary.metric_value))
def update_model_version(self, model_name, model_version, model_path=None, model_metric=None, model_flavor=None,
version_desc=None, current_stage=None) -> Optional[ModelVersionDetail]:
"""
Update metadata for ModelVersion entity and metadata associated with a model version in backend.
Either ``model_path`` or ``model_metric`` or ``model_flavor`` or ``version_desc`` should be non-None.
Backend raises exception if a registered model with given name does not exist.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:param model_version: User-defined version of registered model.
:param model_path: (Optional) Source path where the AIFlow model is stored.
:param model_metric: (Optional) Metric address from AIFlow metric server of registered model.
:param model_flavor: (Optional) Flavor feature of AIFlow registered model option.
:param version_desc: (Optional) Description of registered model version.
:param current_stage: (Optional) Current stage of registered model version.
:return: A single updated :py:class:`ai_flow.model_center.entity.ModelVersionDetail` object.
"""
request = UpdateModelVersionRequest(
model_meta=ModelMetaParam(model_name=stringValue(model_name), model_version=stringValue(model_version)),
model_version=ModelVersionParam(model_path=stringValue(model_path),
model_metric=stringValue(model_metric),
model_flavor=stringValue(model_flavor),
version_desc=stringValue(version_desc),
current_stage=current_stage))
response = self.model_center_stub.updateModelVersion(request)
return ModelVersionDetail.from_proto(_parse_response(response, ModelVersionMeta()))
def to_meta_proto(self):
return ModelVersionMeta(model_name=self.model_name, model_version=self.model_version,
model_path=stringValue(self.model_path),
model_metric=stringValue(self.model_metric),
model_flavor=stringValue(self.model_flavor),
version_desc=stringValue(self.version_desc),
version_status=ModelVersionStatus.from_string(self.version_status),
current_stage=ModelVersionStage.from_string(self.current_stage.upper()))
def project_meta_to_proto(project_meta: ProjectMeta) -> ProjectProto:
if project_meta is None:
return None
else:
return ProjectProto(uuid=project_meta.uuid,
name=project_meta.name,
properties=project_meta.properties,
uri=stringValue(project_meta.uri),
user=stringValue(project_meta.user),
password=stringValue(project_meta.password),
project_type=stringValue(
project_meta.project_type))
def delete_model_version(self, model_name, model_version) -> ModelVersion:
"""
Delete model version by model name and version in Model Center backend.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:param model_version: User-defined version of registered model.
:return: A single :py:class:`ai_flow.entities.model_registry.ModelVersion` object.
"""
request = DeleteModelVersionRequest(model_meta=ModelMetaParam(model_name=stringValue(model_name),
model_version=stringValue(model_version)))
response = self.model_center_stub.deleteModelVersion(request)
return ModelVersion.from_resp_proto(_parse_response(response, ModelMetaParam()))
def artifact_meta_to_proto(artifact_meta: ArtifactMeta) -> ArtifactProto:
if artifact_meta is None:
return None
else:
return ArtifactProto(
uuid=artifact_meta.uuid,
name=artifact_meta.name,
properties=artifact_meta.properties,
data_format=stringValue(artifact_meta.data_format),
description=stringValue(artifact_meta.description),
batch_uri=stringValue(artifact_meta.batch_uri),
stream_uri=stringValue(artifact_meta.stream_uri),
create_time=int64Value(artifact_meta.create_time),
update_time=int64Value(artifact_meta.update_time))
def model_version_meta_to_proto(model_version_relation,
model_center_detail) -> ModelVersionProto:
if model_version_relation is not None and model_center_detail is not None:
return ModelVersionProto(
version=stringValue(model_version_relation.version),
model_id=int64Value(model_version_relation.model_id),
workflow_execution_id=int64Value(
model_version_relation.workflow_execution_id),
model_path=stringValue(model_center_detail.model_path),
model_metric=stringValue(model_center_detail.model_metric),
model_flavor=stringValue(model_center_detail.model_flavor),
version_desc=stringValue(model_center_detail.version_desc),
current_stage=model_center_detail.current_stage)
else:
return None
def job_meta_to_proto(job_meta: JobMeta) -> JobProto:
if job_meta is None:
return None
else:
job_state = StateProto.Value(job_meta.job_state)
return JobProto(uuid=job_meta.uuid,
name=job_meta.name,
workflow_execution_id=int64Value(
job_meta.workflow_execution_id),
job_state=job_state,
properties=job_meta.properties,
job_id=stringValue(job_meta.job_id),
start_time=int64Value(job_meta.start_time),
end_time=int64Value(job_meta.end_time),
log_uri=stringValue(job_meta.log_uri),
signature=stringValue(job_meta.signature))
def workflow_execution_meta_to_proto(
execution_meta: WorkflowExecutionMeta) -> WorkflowExecutionProto:
if execution_meta is None:
return None
else:
execution_state = StateProto.Value(execution_meta.execution_state)
return WorkflowExecutionProto(
uuid=execution_meta.uuid,
name=execution_meta.name,
execution_state=execution_state,
project_id=int64Value(execution_meta.project_id),
properties=execution_meta.properties,
start_time=int64Value(execution_meta.start_time),
end_time=int64Value(execution_meta.end_time),
workflow_json=stringValue(execution_meta.workflow_json),
log_uri=stringValue(execution_meta.log_uri),
signature=stringValue(execution_meta.signature))
def create_registered_model(self, model_name, model_type, model_desc=None) -> Optional[RegisteredModelDetail]:
"""
Create a new registered model from given type in Model Center.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:param model_type: Type of registered model.
:param model_desc: (Optional) Description of registered model.
:return: A single object of :py:class:`ai_flow.model_center.entity.RegisteredModelDetail` created in
Model Center.
"""
request = CreateRegisteredModelRequest(
registered_model=RegisteredModelParam(model_name=stringValue(model_name),
model_type=ModelType.Value(model_type),
model_desc=stringValue(model_desc)))
response = self.model_center_stub.createRegisteredModel(request)
return RegisteredModelDetail.from_proto(_parse_response(response, RegisteredModelMeta()))
def register_metric_summary(self,
metric_id: int,
metric_key: Text,
metric_value: Text
) -> Tuple[int, Text, Optional[MetricSummary]]:
request = metric_service_pb2.MetricSummaryRequest(
metric_summary=message_pb2.MetricSummaryProto(
metric_id=int64Value(metric_id),
metric_key=stringValue(metric_key),
metric_value=stringValue(metric_value))
)
response = self.metric_stub.registerMetricSummary(request)
if 0 == response.return_code:
metric_summary_proto = response.metric_summary
metric_summary = proto_to_metric_summary(metric_summary_proto)
return response.return_code, response.return_msg, metric_summary
else:
return response.return_code, response.return_msg, None
def model_meta_to_proto(model_relation, model_center_detail) -> ModelProto:
if model_relation is not None and model_center_detail is not None:
return ModelProto(uuid=model_relation.uuid,
name=model_relation.name,
project_id=int64Value(model_relation.project_id),
model_type=model_center_detail.model_type,
model_desc=stringValue(
model_center_detail.model_desc))
else:
return None
def model_version_relation_meta_to_proto(
model_version_relation: ModelVersionRelationMeta
) -> ModelVersionRelationProto:
if model_version_relation is None:
return None
else:
return ModelVersionRelationProto(
version=stringValue(model_version_relation.version),
model_id=int64Value(model_version_relation.model_id),
workflow_execution_id=int64Value(
model_version_relation.workflow_execution_id))
def delete_registered_model(self, model_name) -> RegisteredModelDetail:
"""
Delete registered model by model name in Model Center backend.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:return: A single :py:class:`ai_flow.entities.model_registry.RegisteredModel` object.
"""
request = DeleteRegisteredModelRequest(model_meta=ModelMetaParam(model_name=stringValue(model_name)))
response = self.model_center_stub.deleteRegisteredModel(request)
return RegisteredModel.from_resp_proto(_parse_response(response, ModelMetaParam()))
def get_model_version_detail(self, model_name, model_version) -> Optional[ModelVersionDetail]:
"""
Get model version detail filter by model name and model version for Model Center.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:param model_version: User-defined version of registered model.
:return: A single :py:class:`ai_flow.entities.model_registry.ModelVersionDetail` object.
"""
request = GetModelVersionDetailRequest(model_meta=ModelMetaParam(model_name=stringValue(model_name),
model_version=stringValue(model_version)))
response = self.model_center_stub.getModelVersionDetail(request)
return ModelVersionDetail.from_proto(_parse_response(response, ModelVersionMeta()))
def update_registered_model(self, model_name, new_name=None, model_type=None,
model_desc=None) -> Optional[RegisteredModelDetail]:
"""
Update metadata for RegisteredModel entity backend. Either ``model_name`` or ``model_type`` or ``model_desc``
should be non-None. Backend raises exception if a registered model with given name does not exist.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:param new_name: (Optional) New proposed name for the registered model.
:param model_type: (Optional) Type of registered model.
:param model_desc: (Optional) Description of registered model.
:return: A single updated :py:class:`ai_flow.model_center.entity.RegisteredModelDetail` object.
"""
request = UpdateRegisteredModelRequest(model_meta=ModelMetaParam(model_name=stringValue(model_name)),
registered_model=RegisteredModelParam(model_name=stringValue(new_name),
model_type=ModelType.Value(
model_type),
model_desc=stringValue(
model_desc)))
response = self.model_center_stub.updateRegisteredModel(request)
return RegisteredModelDetail.from_proto(_parse_response(response, RegisteredModelMeta()))
def create_model_version(self, model_name, model_path, model_metric, model_flavor=None, version_desc=None,
current_stage=ModelVersionStage.GENERATED) -> Optional[ModelVersionDetail]:
"""
Create a new model version from given source and metric in Model Center.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:param model_path: Source path where the AIFlow model is stored.
:param model_metric: Metric address from AIFlow metric server of registered model.
:param model_flavor: (Optional) Flavor feature of AIFlow registered model option.
:param version_desc: (Optional) Description of registered model version.
:param current_stage: (Optional) Stage of registered model version.
:return: A single object of :py:class:`ai_flow.model_center.entity.ModelVersionDetail` created in
model repository.
"""
request = CreateModelVersionRequest(model_meta=ModelMetaParam(model_name=stringValue(model_name)),
model_version=ModelVersionParam(model_path=stringValue(model_path),
model_metric=stringValue(model_metric),
model_flavor=stringValue(model_flavor),
version_desc=stringValue(version_desc),
current_stage=current_stage))
response = self.model_center_stub.createModelVersion(request)
return ModelVersionDetail.from_proto(_parse_response(response, ModelVersionMeta()))
def metric_meta_to_proto(metric_meta: MetricMeta) -> MetricMetaProto:
if metric_meta.metric_type == MetricType.DATASET:
metric_type = MetricTypeProto.DATASET
else:
metric_type = MetricTypeProto.MODEL
return MetricMetaProto(
uuid=metric_meta.uuid,
name=stringValue(metric_meta.name),
dataset_id=int64Value(metric_meta.dataset_id),
model_name=stringValue(metric_meta.model_name),
model_version=stringValue(metric_meta.model_version),
job_id=int64Value(metric_meta.job_id),
start_time=int64Value(metric_meta.start_time),
end_time=int64Value(metric_meta.end_time),
metric_type=metric_type,
uri=stringValue(metric_meta.uri),
tags=stringValue(metric_meta.tags),
metric_description=stringValue(metric_meta.metric_description),
properties=metric_meta.properties)
def update_metric_meta(self,
uuid: int,
name: Text = None,
dataset_id: int = None,
model_name: Optional[Text] = None,
model_version: Optional[Text] = None,
job_id: int = None,
start_time: int = None,
end_time: int = None,
metric_type: MetricType = MetricType.DATASET,
uri: Text = None,
tags: Text = None,
metric_description: Text = None,
properties: Properties = None,
) -> Tuple[int, Text, Optional[MetricMeta]]:
pb_metric_type = message_pb2.MetricTypeProto.Value(metric_type.value)
request = metric_service_pb2.MetricMetaRequest(
metric_meta=message_pb2.MetricMetaProto(
uuid=uuid,
name=stringValue(name),
dataset_id=int64Value(dataset_id),
model_name=stringValue(model_name),
model_version=stringValue(model_version),
job_id=int64Value(job_id),
start_time=int64Value(start_time),
end_time=int64Value(end_time),
metric_type=pb_metric_type,
uri=stringValue(uri),
tags=stringValue(tags),
metric_description=stringValue(metric_description),
properties=properties)
)
response = self.metric_stub.updateMetricMeta(request)
if 0 == response.return_code:
metric_meta_proto = response.metric_meta
metric_meta = proto_to_metric_meta(metric_meta_proto)
return response.return_code, response.return_msg, metric_meta
else:
return response.return_code, response.return_msg, None
def example_meta_to_proto(example_mata) -> ExampleProto:
if example_mata is None:
return None
else:
example_support_type = ExampleSupportTypeProto.Value(
example_mata.support_type)
if example_mata.schema is not None:
name_list = example_mata.schema.name_list
type_list = example_mata.schema.type_list
data_type_list = []
if type_list is not None:
for data_type in type_list:
data_type_list.append(DataTypeProto.Value(data_type))
else:
data_type_list = None
else:
name_list = None
data_type_list = None
schema = SchemaProto(name_list=name_list, type_list=data_type_list)
return ExampleProto(
uuid=example_mata.uuid,
name=example_mata.name,
support_type=example_support_type,
properties=example_mata.properties,
data_type=stringValue(example_mata.data_type),
data_format=stringValue(example_mata.data_format),
description=stringValue(example_mata.description),
batch_uri=stringValue(example_mata.batch_uri),
stream_uri=stringValue(example_mata.stream_uri),
create_time=int64Value(example_mata.create_time),
update_time=int64Value(example_mata.update_time),
schema=schema,
catalog_name=stringValue(example_mata.catalog_name),
catalog_type=stringValue(example_mata.catalog_type),
catalog_database=stringValue(example_mata.catalog_database),
catalog_connection_uri=stringValue(
example_mata.catalog_connection_uri),
catalog_version=stringValue(example_mata.catalog_version),
catalog_table=stringValue(example_mata.catalog_table))
def get_registered_model_detail(self, model_name) -> Optional[RegisteredModelDetail]:
"""
Get registered model detail filter by model name for Model Center.
:param model_name: Name of registered model. This is expected to be unique in the backend store.
:return: A single :py:class:`ai_flow.entities.model_registry.RegisteredModelDetail` object.
"""
request = GetRegisteredModelDetailRequest(model_meta=ModelMetaParam(model_name=stringValue(model_name)))
response = self.model_center_stub.getRegisteredModelDetail(request)
return RegisteredModelDetail.from_detail_proto(_parse_response(response, ProtoModelDetail()))
