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)
