def list_model_versions(name, **kwargs): """list versions of a model :param name: The unique name of the model :type name: str :rtype: PageTokenListSerializer """ model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() filter_string = "name='{}'".format(name) versions = mlflow_client.search_model_versions(filter_string) data = [ ModelVersionSerializer( creation_timestamp=version.creation_timestamp, current_stage=version.current_stage, description=version.description, last_updated_timestamp=version.last_updated_timestamp, name=version.name, run_id=version.run_id, source=version.source, status=version.status, status_message=version.status_message, tags=version.tags, version=version.version) for version in versions ] return PageTokenListSerializer(data=data, next_page_token="")
def update_model_version(name, version, body=None, **kwargs): """update a model version :param name: The unique name of the model :type name: str :param version: The version of the model to retrieve :type version: str :param body: :type body: dict | bytes :rtype: ModelVersionSerializer """ model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() serializer = ModelVersionSerializer.from_dict(body) model_version = mlflow_client.update_model_version( name, version, description=serializer.description) ModelVersionSerializer( creation_timestamp=model_version.creation_timestamp, current_stage=model_version.current_stage, description=model_version.description, last_updated_timestamp=model_version.last_updated_timestamp, name=model_version.name, run_id=model_version.run_id, source=model_version.source, status=model_version.status, status_message=model_version.status_message, tags=model_version.tags, version=model_version.version)
def transition_model_version_stage(name, version, body, **kwargs): """Transition model version stage :param name: The unique name of the model :type name: str :param version: The version of the model :type version: str :param body: :type body: dict | bytes :rtype: ModelVersionSerializer """ model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() version = mlflow_client.transition_model_version_stage( name, version, body["stage"]) return ModelVersionSerializer( creation_timestamp=version.creation_timestamp, current_stage=version.current_stage, description=version.description, last_updated_timestamp=version.last_updated_timestamp, name=version.name, run_id=version.run_id, source=version.source, status=version.status, status_message=version.status_message, tags=version.tags, version=version.version)
def create_model_version(name, body, **kwargs): """Create a model version :param name: The unique name of the model :type name: str :param body: Request payload to create a model version :type body: dict | bytes :rtype: ModelVersionSerializer """ serializer = ModelVersionSerializer.from_dict(body) model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() version = mlflow_client.create_model_version( name=name, source=serializer.source, run_id=serializer.run_id, tags=serializer.tags, description=serializer.description) return ModelVersionSerializer( creation_timestamp=version.creation_timestamp, current_stage=version.current_stage, description=version.description, last_updated_timestamp=version.last_updated_timestamp, name=version.name, run_id=version.run_id, source=version.source, status=version.status, status_message=version.status_message, tags=version.tags, version=version.version)
def get_model_version(name, version, **kwargs): """get a model version :param name: The unique name of the model :type name: str :param version: The version of the model to retrieve :type version: str :rtype: ModelVersionSerializer """ model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() version = mlflow_client.get_model_version(name, version) return ModelVersionSerializer( creation_timestamp=version.creation_timestamp, current_stage=version.current_stage, description=version.description, last_updated_timestamp=version.last_updated_timestamp, name=version.name, run_id=version.run_id, source=version.source, status=version.status, status_message=version.status_message, tags=version.tags, version=version.version)
def create_model(body, **kwargs): """Create a model :param body: Request payload to create a model :type body: dict | bytes :rtype: ModelSerializer """ serializer = ModelSerializer.from_dict(body) description = serializer.description if serializer.description else "" project_id = serializer.tags.get("ilyde.project") if not project_id: raise connexion.ProblemException( status=400, title="Bad Request", detail= "ilyde.project tag should be provided with the id of the project.") stub = get_projects_services_stub() project = stub.Retrieve(project_pb2.ID(id=project_id)) if not permissions.IsProjectMember.has_object_permission( kwargs["token_info"], project): raise connexion.ProblemException( status=403, title="Permission Denied", detail="Doesn't have enough permissions to take this action") model_name = util.safe_model_name(serializer.name) if not model_name.startswith(util.safe_model_name(project.name)): model_name = "{}-{}".format(util.safe_model_name(project.name), model_name) mlflow_client = get_mlflow_client() model = mlflow_client.create_registered_model(name=model_name, description=description, tags=serializer.tags) return ModelSerializer( name=model.name, description=model.description, tags=model.tags, latest_versions=[ ModelVersionSerializer( creation_timestamp=version.creation_timestamp, current_stage=version.current_stage, description=version.description, last_updated_timestamp=version.last_updated_timestamp, name=version.name, run_id=version.run_id, source=version.source, status=version.status, status_message=version.status_message, tags=version.tags, version=version.version) for version in model.latest_versions ], last_updated_timestamp=model.last_updated_timestamp, creation_timestamp=model.creation_timestamp)
def delete_model(name, **kwargs): """Delete a model :param name: The unique name of the model :type name: str :rtype: StatusSerializer """ model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() mlflow_client.delete_registered_model(name) return StatusSerializer(status=200, message="successfully deleted")
def signature_modelapi(id_, **kwargs): """Get signature of modelapi :param id_: The ID of the modelapi resource :type id_: str :rtype: object """ modelapi = get_modelapi_object(id_) mlflow_client = get_mlflow_client() model_version = mlflow_client.get_model_version(modelapi.spec.model, modelapi.spec.version) run = mlflow_client.get_run(run_id=model_version.run_id) model_spec = json.loads(run.data.tags.get("mlflow.log-model.history"))[0] return model_spec.get("signature", {})
def delete_model_version(name, version, **kwargs): """delete a model version :param name: The unique name of the model :type name: str :param version: The version of the model to delete :type version: str :rtype: StatusSerializer """ model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() mlflow_client.delete_model_version(name, version) return StatusSerializer(status=200, message="successfully deleted")
def list_project_models(id_, **kwargs): """List project's models :param id_: The ID of the project resource :type id_: str :rtype: PageTokenListSerializer """ proj = get_project_object(id_) check_project_permission(proj, kwargs["token_info"]) mlflow_client = get_mlflow_client() models = mlflow_client.list_registered_models(max_results=200) data = [] for model in models: project_id = model.tags.get('ilyde.project', None) if project_id == proj.id: data.append(model) return PageTokenListSerializer( next_page_token=models.token, data=[ ModelSerializer( name=model.name, description=model.description, tags=model.tags, latest_versions=[ ModelVersionSerializer( creation_timestamp=version.creation_timestamp, current_stage=version.current_stage, description=version.description, last_updated_timestamp=version.last_updated_timestamp, name=version.name, run_id=version.run_id, source=version.source, status=version.status, status_message=version.status_message, tags=version.tags, version=version.version) for version in model.latest_versions ], last_updated_timestamp=model.last_updated_timestamp, creation_timestamp=model.creation_timestamp) for model in data ])
def get_experiment_artifacts(id_, **kwargs): """Get artifacts of a succeeded experiment. :param id_: The ID of the experiment resource :type id_: str :rtype: ArtifactsSerializer """ exp = get_experiment_object(id_) check_experiment_permission(exp, kwargs["token_info"]) mlflow_client = get_mlflow_client() all_experiments = [ e.experiment_id for e in mlflow_client.list_experiments() ] runs = mlflow_client.search_runs( experiment_ids=all_experiments, filter_string="tags.`ilyde.job` = '{}'".format(exp.id), run_view_type=ViewType.ALL) if not runs: return ArtifactsSerializer(data=[]) run = runs[0] dirs = [] data = [] path = None while True: artifacts = mlflow_client.list_artifacts(run_id=run.info.run_id, path=path) for artifact in artifacts: if artifact.is_dir: dirs.append(artifact.path) else: data.append( FileSerializer(name=artifact.path, is_dir=artifact.is_dir, size=artifact.file_size)) if not dirs: break path = dirs.pop(0) return ArtifactsSerializer(data=data)
def get_experiment_artifact(id_, path, **kwargs): # noqa: E501 """Download experiment artifact Download experiment artifact :param id_: The ID of the experiment resource :type id_: str :param path: File's path to download :type path: str :rtype: file """ stub = get_experiments_services_stub() experiment = stub.Get(job_pb2.ID(id=id_)) stub = get_projects_services_stub() project = stub.Retrieve(project_pb2.ID(id=experiment.metadata.project)) if not IsProjectMember.has_object_permission(kwargs["token_info"], project): return ErrorSerializer(status=403, title="Permission Denied", detail="Doesn't have enough permissions to take this action"), 403 mlflow_client = get_mlflow_client() all_experiments = [exp.experiment_id for exp in mlflow_client.list_experiments()] run = mlflow_client.search_runs(experiment_ids=all_experiments, filter_string="tags.`ilyde.job` = '{}'".format(experiment.id), run_view_type=ViewType.ALL)[0] local_dir = os.path.dirname(os.path.join(current_app.config.get("BASE_DIR"), "media", run.info.run_id, path)) if not os.path.exists(local_dir): os.makedirs(local_dir, exist_ok=True) local_path = mlflow_client.download_artifacts(run.info.run_id, path, local_dir) file_type, _ = mimetypes.guess_type(local_path) if file_type is None: file_type = 'application/octet-stream' with open(local_path, 'rb') as f: response = make_response(f.read()) response.headers.set('Content-Type', file_type) return response, 200
def update_model(name, body, **kwargs): """Update a model :param name: The unique name of the model :type name: str :param body: :type body: dict | bytes :rtype: ModelSerializer """ model = get_mlflow_model(name) check_model_permission(model, kwargs["token_info"]) mlflow_client = get_mlflow_client() serializer = ModelSerializer.from_dict(body) model = mlflow_client.update_registered_model( name, description=serializer.description) return ModelSerializer( name=model.name, description=model.description, tags=model.tags, latest_versions=[ ModelVersionSerializer( creation_timestamp=version.creation_timestamp, current_stage=version.current_stage, description=version.description, last_updated_timestamp=version.last_updated_timestamp, name=version.name, run_id=version.run_id, source=version.source, status=version.status, status_message=version.status_message, tags=version.tags, version=version.version) for version in model.latest_versions ], last_updated_timestamp=model.last_updated_timestamp, creation_timestamp=model.creation_timestamp)
def get_experiment_results(id_, **kwargs): """Get results of a succeeded experiment. :param id_: The ID of the experiment resource :type id_: str :rtype: dict """ exp = get_experiment_object(id_) check_experiment_permission(exp, kwargs["token_info"]) mlflow_client = get_mlflow_client() all_experiments = [ e.experiment_id for e in mlflow_client.list_experiments() ] runs = mlflow_client.search_runs( experiment_ids=all_experiments, filter_string="tags.`ilyde.job` = '{}'".format(exp.id), run_view_type=ViewType.ALL) if not runs: return {} return runs[0].to_dictionary()
def get_mlflow_model(name): mlflow_client = get_mlflow_client() return mlflow_client.get_registered_model(name)