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