MLflow REST API client #

Parameters:

namestr: Model name
version: int: Version number

Returns:

model_versionmlflow_rest_client.model.ModelVersion: Updated model version

Examples

model_version = client.archive_model_version("some_run_id", 1)

create_experiment(name, artifact_location=None)#

Create experiment

Return type:

Experiment

Parameters:

namestr: Experiment name
artifact_locationstr, optional: Path for artifacts

Returns:

experiment: mlflow_rest_client.experiment.Experiment: New experiment

Examples

experiment = client.create_experiment("some_experiment")

experiment = client.create_experiment("some_experiment", artifact_location="some/path")

create_model(name, tags=None)#

Create model

Return type:

Parameters:

namestr: Model name
tagsdict, list of dict, optional: List of run tags

Returns:

model: mlflow_rest_client.modelModel: New model

Examples

model = client.create_model("some_model")

tags = {"some": "tag"}
# or
tags = [{"key": "some", "value": "tag"}]
model = client.create_model("some_model", tags=tags)

create_model_version(name, source=None, run_id=None, tags=None)#

Create model version

Return type:

Parameters:

namestr: Model name
sourcestr: Model version source path
run_idstr: Run ID used for generating model
tagsdict, list of dict, optional: List of model tags

Returns:

model_versionmlflow_rest_client.model.ModelVersion: ModelVersion

Examples

name = "some_model"
model_version = client.create_model_version(name)

source = "my_script.py"
model_version = client.create_model_version(name, source=source)

run_id = "some_run_id"
model_version = client.create_model_version(name, run_id=run_id)

tags = {"some": "tag"}
# or
tags = [{"key": "some", "value": "tag"}]
model_version = client.create_model_version(name, tags=tags)

create_run(experiment_id, start_time=None, tags=None)#

Create run

Return type:

Run

Parameters:

experiment_idint: Experiment ID
start_timeint or datetime.datetime, optional: Start time
tagsdict, list of dict, optional: List of run tags

Returns:

runmlflow_rest_client.run.Run: Run

Examples

experiment_id = 123
run = client.create_run(experiment_id)
run = client.create_run(experiment_id, start_time=datetime.datetime.now())

tags = {"some": "tag"}
# or
tags = [{"key": "some", "value": "tag"}]
run = client.create_run(experiment_id, tags=tags)

delete_experiment(experiment_id)#

Delete experiment

Return type:

None

Parameters:

experiment_idint: Experiment ID

Examples

client.delete_experiment(123)

delete_model(name)#

Delete model

Return type:

None

Parameters:

namestr: Model name

Examples

client.delete_model("some_model")

delete_model_tag(name, key)#

Delete model tag

Parameters:

namestr: Model name
keystr: Tag name

Examples

client.delete_model_tag("some_model", "some.tag")

delete_model_version(name, version)#

Delete model version

Return type:

None

Parameters:

namestr: Model name
version: int: Version number

Examples

client.delete_model_version("some_model", 1)

delete_model_version_tag(name, version, key)#

Delete model version tag

Return type:

None

Parameters:

namestr: Model name
version: int: Version number
keystr: Tag name

Examples

client.delete_model_version_tag("some_model", 1, "some.tag")

delete_run(run_id)#

Delete run

Return type:

None

Parameters:

run_idUUID: Run ID

Examples

client.delete_run("some_run_id")

delete_run_tag(run_id, key)#

Delete run tag

Return type:

None

Parameters:

run_idUUID: Run ID
keystr: Tag name

Examples

client.delete_run_tag("some_run_id", "some.tag")

delete_run_tags(run_id, keys)#

Delete run tags

Return type:

None

Parameters:

run_idstr: Run ID
tags: :obj:`dict`, :obj:`list` of :obj:`dict`: Run tags list

Examples

run_tags = {"some": "tag"}
# or
run_tags = [{"key": "some", "value": "param"}]

client.delete_run_tags("some_run_id", run_tags)

fail_run(run_id, end_time=None)#

Change run status to FAILED

Return type:

Parameters:

run_idstr: Run ID
end_timeint or datetime.datetime, optional: End time

Returns:

run_infomlflow_rest_client.run.Runinfo: Run info

Examples

run_info = client.fail_run("some_run_id")
run_info = client.fail_run("some_run_id", end_time=datetime.datetime.now())

finish_run(run_id, end_time=None)#

Change run status to FINISHED

Return type:

Parameters:

run_idstr: Run ID
end_timeint or datetime.datetime, optional: End time

Returns:

run_infomlflow_rest_client.run.Runinfo: Run info

Examples

run_info = client.finish_run("some_run_id")
run_info = client.finish_run("some_run_id", end_time=datetime.datetime.now())

get_experiment(experiment_id)#

Get experiment by its id

Return type:

Experiment

Parameters:

experiment_idint: Experiment ID

Returns:

experiment: mlflow_rest_client.experiment.Experiment: Experiment

Examples

experiment = client.get_experiment(123)

get_experiment_by_name(name)#

Get experiment by its name

Return type:

Optional[Experiment]

Parameters:

namestr: Experiment name

Returns:

experiment: mlflow_rest_client.experiment.Experiment or None: Experiment, if exists

Examples

experiment = client.get_experiment_by_name("some_experiment")

get_experiment_id(name)#

Get experiment id by name

Return type:

Optional[int]

Parameters:

namestr: Experiment name

Returns:

idstr or None: Experiment ID, if exists

Examples

experiment_id = client.get_experiment_id("some_experiment")

get_model(name)#

Get model by name

Return type:

Parameters:

name: str: Model name

Returns:

modelmlflow_rest_client.run.Model: Model

Examples

model = client.get_model("some_model")

get_model_version(name, version)#

Get model version

Return type:

Parameters:

name: str: Model name
version: int: Version number

Returns:

model_versionmlflow_rest_client.run.ModelVersion: ModelVersion

Examples

model_version = client.get_model_version("some_model", 1)

get_model_version_download_url(name, version)#

Get download URL for model artifact by version

Return type:

Optional[str]

Parameters:

namestr: Model name
version: int: Version number

Returns:

download_url: str: Artifact URL

Examples

download_url = client.get_model_version_download_url("some_model", 1)

get_or_create_experiment(name, artifact_location=None)#

Get existing experiment by name or create new one

Return type:

Experiment

Parameters:

namestr: Experiment name
artifact_locationstr, optional: Path for artifacts

Returns:

experimentmlflow_rest_client.experiment.Experiment: New or existing experiment

Examples

experiment = client.get_or_create_experiment("some_experiment")

get_or_create_model(name, tags=None)#

Get existing model by name or create new one

Return type:

Parameters:

namestr: Model name
tagsdict, list of dict, optional: List of run tags

Returns:

model: mlflow_rest_client.modelModel: New or existing model

Examples

model = client.get_or_create_model("some_model")

tags = {"some": "tag"}
# or
tags = [{"key": "some", "value": "tag"}]
model = client.get_or_create_model("some_model", tags=tags)

get_run(run_id)#

Get run by ID

Return type:

Run

Parameters:

run_idstr: Run ID

Returns:

runmlflow_rest_client.run.Run: Run

Examples

run = client.get_run("some_run_id")

kill_run(run_id, end_time=None)#

Change run status to KILLED

Return type:

Parameters:

run_idstr: Run ID
end_timeint or datetime.datetime, optional: End time

Returns:

run_infomlflow_rest_client.run.Runinfo: Run info

Examples

run_info = client.kill_run("some_run_id")
run_info = client.kill_run("some_run_id", end_time=datetime.datetime.now())

list_experiment_runs(experiment_id)#

List experiments runs

Return type:

list[Run]

Parameters:

experiment_idint: Experiment ID

Returns:

runslist of mlflow_rest_client.run.Run: Runs list

Examples

runs = client.list_experiment_runs(123)

list_experiment_runs_iterator(experiment_id)#

Iterate by experiment runs

Return type:

Iterator

Parameters:

experiment_idint: Experiment ID

Returns:

runsIterator of mlflow_rest_client.run.Run: Runs iterator

Examples

for run in client.list_experiment_runs_iterator(123):
    print(run)

list_experiments(view_type=RunViewType.ACTIVE)#

List all existing experiments in MLflow database

Return type:

list[Experiment]

Parameters:

view_typemlflow_rest_client.run.RunViewType, optional: View type

Returns:

experiments_list: mlflow_rest_client.experiment.ExperimentList: Experiments list

Examples

experiments_list = client.list_experiments()

list_experiments_iterator(view_type=RunViewType.ACTIVE)#

Iterate by all existing experiments in MLflow database

Return type:

Iterator[Experiment]

Parameters:

view_typemlflow_rest_client.run.RunViewType, optional: View type

Returns:

experiments_iterator: Iterator of mlflow_rest_client.experiment.Experiment: Experiments iterator

Examples

for experiment in client.list_experiments_iterator():
    print(experiment)

list_model_all_versions(name, stages=None)#

List model versions (all versions of each stage)

Return type:

ListableModelVersion

Parameters:

namestr: Model name
stageslist of mlflow_rest_client.model.ModelVersionStage or list of str, optional: Model stages to fetch

Returns:

model_versions_listmlflow_rest_client.model.ModelVersionList: Model versions list

Examples

model_versions_list = client.list_model_all_versions("some_model")
model_versions_list = client.list_model_all_versions(
    "some_model", stages=[ModelVersionStage.PROD]
)

list_model_all_versions_iterator(name, stages=None)#

Iterate by models versions (all versions of each stage)

Return type:

Iterator

Parameters:

namestr: Model name
stageslist of mlflow_rest_client.model.ModelVersionStage or list of str, optional: Model stages to fetch

Returns:

model_versions_iteratorIterator or mlflow_rest_client.model.ModelVersion: Model versions iterator

Examples

for model_version in client.list_model_all_versions_iterator("some_model"):
    print(model_version)

for model_version in client.list_model_all_versions_iterator(
    "some_model", stages=[ModelVersionStage.PROD]
):
    print(model_version)

list_model_versions(name, stages=None)#

List model versions (only latest version of each stage)

Return type:

ListableModelVersion

Parameters:

namestr: Model name
stageslist of mlflow_rest_client.model.ModelVersionStage or list of str, optional: Model stages to fetch

Returns:

model_versions_listmlflow_rest_client.model.ModelVersionList: Model versions list

Examples

model_versions_list = client.list_model_versions("some_model")
model_versions_list = client.list_model_versions(
    "some_model", stages=[ModelVersionStage.PROD]
)

list_model_versions_iterator(name, stages=None)#

Iterate by models versions (only latest version of each stage)

Return type:

Iterator

Parameters:

namestr: Model name
stageslist of mlflow_rest_client.model.ModelVersionStage or list of str, optional: Model stages to fetch

Returns:

model_versions_iteratorIterator or mlflow_rest_client.model.ModelVersion: Model versions iterator

Examples

for model_version in client.list_model_versions_iterator("some_model"):
    print(model_version)

for model_version in client.list_model_versions_iterator(
    "some_model", stages=[ModelVersionStage.PROD]
):
    print(model_version)

list_models(max_results=100, page_token=None)#

List models

Return type:

Parameters:

max_resultsint, optional: Max results to return
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

models_pagemlflow_rest_client.page.Page of mlflow_rest_client.model.Model: Models page

Examples

models_page = client.list_models()
models_page = client.list_models(max_results=1000)
models_page = client.list_models(page_token="next_page_id")

list_models_iterator(max_results=100, page_token=None)#

Iterate by models

Like list_models, but automatically fetches next page while iteration, until no pages left.

Return type:

Iterator

Parameters:

max_resultsint, optional: Max results to return
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

modelsIterator of mlflow_rest_client.model.Model: Models iterator

Examples

for model in client.list_models():
    print(model)

for model in client.list_models(max_results=1000):
    print(model)

for model in client.list_models(page_token="next_page_id"):
    print(model)

list_run_artifacts(run_id, path=None, page_token=None)#

List run artifacts

Return type:

Parameters:

run_idUUID: Run ID
pathstr, optional: Artifacts path to search (can contain *)
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

artifacts_page: mlflow_rest_client.page.Page of mlflow_rest_client.artifact.Artifact: Artifacts page

Examples

artifacts_page = client.list_run_artifacts("some_run_id")
artifacts_page = client.list_run_artifacts("some_run_id", path="some/path/*")
artifacts_page = client.list_run_artifacts("some_run_id", page_token="next_page_id")

list_run_artifacts_iterator(run_id, path=None, page_token=None)#

Iterate by run artifacts

Like list_run_artifacts, but automatically fetches next page while iteration, until no pages left.

Return type:

Iterator[Artifact]

Parameters:

run_idstr: Run ID
pathstr, optional: Artifacts path to search (can contain *)
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

artifacts: Iterator of mlflow_rest_client.artifact.Artifact: Artifacts iterator

Examples

for artifact in client.list_run_artifacts_iterator("some_run_id"):
    print(artifact)

for artifact in client.list_run_artifacts_iterator("some_run_id", path="some/path/*"):
    print(artifact)

for artifact in client.list_run_artifacts_iterator(
    "some_run_id", page_token="next_page_id"
):
    print(artifact)

list_run_metric_history(run_id, key)#

List metric history

Return type:

list[Metric]

Parameters:

run_idUUID: Run ID
keystr: Metric name

Returns:

metrics: mlflow_rest_client.run.Metric: Metrics list

Examples

metrics_list = client.list_run_metric_history("some_run_id", "some.metric")

list_run_metric_history_iterator(run_id, key)#

Iterate by metric history

Return type:

Iterator[Metric]

Parameters:

run_idstr: Run ID
keystr: Metric name

Returns:

metrics: Iterator of mlflow_rest_client.run.Metric: Metrics iterator

Examples

for metric in client.list_run_metric_history_iterator("some_run_id", "some.metric"):
    print(metric)

log_run_batch(run_id, params=None, metrics=None, timestamp=None, tags=None)#

Add or update run parameters, mertics or tags withit one request

Return type:

None

Parameters:

run_idUUID: Run ID
paramsdict or list of dict, optional: Params list
metricsdict or list of dict, optional: Metrics list
timestampint or datetime.datetime, optional: Run tags Default timestamp for metric
tagsdict or list of dict, optional: Run tags list

Examples

params = {"some": "param"}
# or
params = [{"key": "some", "value": "param"}]
client.log_run_batch("some_run_id", params=params)

metrics = {"some": 0.1}
# or
metrics = [
    {"key": "some", "value": 0.1, "step": 0, "timestamp": datetime.datetime.now()}
]
client.log_run_batch("some_run_id", metrics=metrics)

metrics = {"some": 0.1}
# or
metrics = [{"key": "some", "value": 0.1, "step": 0}]
client.log_run_batch("some_run_id", metrics=metrics, timestamp=datetime.datetime.now())

run_tags = {"some": "tag"}
# or
run_tags = [{"key": "some", "value": "param"}]

client.log_run_batch("some_run_id", tags=run_tags)

log_run_metric(run_id, key, value, step=0, timestamp=None)#

Add or update run metric value

Return type:

None

Parameters:

run_idUUID: Run ID
keystr: Metric name
valuefloat: Metric value
stepint, optional: Metric step (default: 0)
timestampint or datetime.datetime, optional: Metric timestamp

Examples

client.log_run_metric("some_run_id", "some.metric", 123)
client.log_run_metric("some_run_id", "some.metric", 123, step=2)
client.log_run_metric(
    "some_run_id", "some.metric", 123, timestamp=datetime.datetime.now()
)

log_run_metrics(run_id, metrics, timestamp=None)#

Add or update run parameters

Return type:

None

Parameters:

run_idstr: Run ID
metricsdict or list of dict: Metrics
timestampint or datetime.datetime, optional: Metric timestamp

Examples

metrics = {"some": 0.1}
# or
metrics = [
    {"key": "some", "value": 0.1, "step": 0, "timestamp": datetime.datetime.now()}
]
client.log_run_metrics("some_run_id", metrics)

log_run_model(run_id, model)#

Add or update run model description

Return type:

None

Parameters:

run_idUUID: Run ID
modeldict: MLmodel JSON description

Examples

model = {
    "flavors": {
        "sklearn": {"sklearn_version": "0.19.1", "pickled_model": "model.pkl"},
        "python_function": {"loader_module": "mlflow.sklearn"},
    }
}

client.log_run_model("some_run_id", model)

log_run_parameter(run_id, key, value)#

Add or update run parameter value

Return type:

None

Parameters:

run_idUUID: Run ID
keystr: Parameter name
valuestr: Parameter value

Examples

client.log_run_parameter("some_run_id", "some.param", "some_value")

log_run_parameters(run_id, params)#

Add or update run parameters

Return type:

None

Parameters:

run_idstr: Run ID
paramsdict or list of dict: Parameters

Examples

params = {"some": "param"}
# or
params = [{"key": "some", "value": "param"}]
client.log_run_parameters("some_run_id", params)

promote_model_version(name, version, **params)#

Change model version stage to Production

Return type:

Parameters:

namestr: Model name
version: int: Version number
archive_existingbool, optional: If True, previous model versions should be archived

Returns:

model_versionmlflow_rest_client.model.ModelVersion: Updated model version

Examples

model_version = client.promote_model_version("some_run_id", 1)
model_version = client.promote_model_version("some_run_id", 1, archive_existing=True)

rename_experiment(experiment_id, new_name)#

Rename experiment

Return type:

None

Parameters:

experiment_idint: Experiment id
new_namestr: New experiment name

Examples

client.rename_experiment(123, "new_experiment")

rename_model(name, new_name)#

Rename model

Return type:

Parameters:

namestr: Old model name
new_namestr: New model name

Returns:

model: mlflow_rest_client.model.Model: Updated model

Examples

model = client.rename_model("old_model", "new_model")

restore_experiment(experiment_id)#

Restore experiment

Return type:

None

Parameters:

experiment_idint: Experiment ID

Examples

client.restore_experiment(123)

restore_run(run_id)#

Restore run

Return type:

None

Parameters:

run_idUUID: Run ID

Examples

client.restore_run("some_run_id")

schedule_run(run_id)#

Change run status to SCHEDULED

Return type:

Parameters:

run_idstr: Run ID

Returns:

run_infomlflow_rest_client.run.Runinfo: Run info

Examples

run_info = client.schedule_run("some_run_id")

search_model_versions(query, max_results=None, order_by=None, page_token=None)#

Search for model versions

Return type:

Parameters:

querystr: Query to search
max_resultsint, optional: Max results to return
order_bylist of str, optional: Order by expression
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

model_versions_page: mlflow_rest_client.page.Page of mlflow_rest_client.model.ModelVersion: Model versions page

Examples

query = "name='some_model'"

model_versions_page = client.search_model_versions(query)

order_by = ["name", "version ASC"]
model_versions_page = client.search_model_versions(query, order_by=order_by)

model_versions_page = client.search_model_versions(query, max_results=100)
model_versions_page = client.search_model_versions(query, page_token="next_page_id")

search_model_versions_iterator(query, max_results=100, order_by=None, page_token=None)#

Iterate by model versions

Like search_model_versions, but automatically fetches next page while iteration, until no pages left.

Return type:

Iterator

Parameters:

querystr: Query to search
max_resultsint, optional: Max results to return
order_bylist of str, optional: Order by expression
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

model_versions_iterator: Iterator of mlflow_rest_client.model.ModelVersion: Model versions iterator

Examples

query = "name='some_model'"

for model_versions in client.search_model_versions(query):
    print(page)

order_by = ["name", "version ASC"]
for model_versions in client.search_model_versions_iterator(query, order_by=order_by):
    print(page)

for model_versions in client.search_model_versions_iterator(query, max_results=100):
    print(page)
for model_versions in client.search_model_versions_iterator(
    query, page_token="next_page_id"
):
    print(page)

search_models(query, max_results=None, order_by=None, page_token=None)#

Search for models

Return type:

Parameters:

querystr: Query to search
max_resultsint, optional: Max results to return
order_bylist of str, optional: Order by expression
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

models_page: mlflow_rest_client.page.Page of mlflow_rest_client.model.Model: Models page

Examples

query = "name = 'some_model%'"  # or "name LIKE "some-model%"'

models_page = client.search_models(query)

order_by = ["name", "version ASC"]
models_page = client.search_models(query, order_by=order_by)

models_page = client.search_models(query, max_results=100)
models_page = client.search_models(query, page_token="next_page_id")

search_models_iterator(query, max_results=100, order_by=None, page_token=None)#

Iterate models found by search query

Like search_models, but automatically fetches next page while iteration, until no pages left.

Return type:

Iterator

Parameters:

querystr: Query to search
max_resultsint, optional: Max results to return
order_bylist of str, optional: Order by expression
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

models: Iterator of mlflow_rest_client.model.Model: Models iterator

Examples

query = "name = 'some_model%'"  # or "name LIKE "some-model%"'

for model in client.search_models_iterator(query):
    print(model)

order_by = ["name", "version ASC"]
for model in client.search_models_iterator(query, order_by=order_by):
    print(model)

for model in client.search_models_iterator(query, max_results=100):
    print(model)

for model in client.search_models_iterator(query, page_token="next_page_id"):
    print(model)

search_runs(experiment_ids, query='', run_view_type=RunViewType.ACTIVE, max_results=100, order_by=None, page_token=None)#

Search for runs

Return type:

Parameters:

experiment_idslist of int: Experiment IDS
querystr, optional: Query to search
run_view_typemlflow_rest_client.run.RunViewType, optional: View type
max_resultsint, optional: Max results to return
order_bylist of str, optional: Order by expression
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

runs_page: mlflow_rest_client.page.Page of mlflow_rest_client.run.Run: Runs page

Examples

experiment_ids = [123]

runs_page = client.search_runs(experiment_ids)

query = "metrics.rmse < 1 and params.model_class = 'LogisticRegression'"
runs_page = client.search_runs(experiment_ids, query=query)

order_by = ["name", "version ASC"]
runs_page = client.search_runs(experiment_ids, order_by=order_by)

runs_page = client.search_runs(experiment_ids, run_view_type=RunViewType.ALL)
runs_page = client.search_runs(experiment_ids, max_results=100)
runs_page = client.search_runs(experiment_ids, page_token="next_page_id")

search_runs_iterator(experiment_ids, query='', run_view_type=RunViewType.ACTIVE, max_results=100, order_by=None, page_token=None)#

Iterate by runs

Like search_runs, but automatically fetches next page while iteration, until no pages left.

Return type:

Iterator[Run]

Parameters:

experiment_idslist of int: Experiment IDS
querystr, optional: Query to search
run_view_typemlflow_rest_client.run.RunViewType, optional: View type
max_resultsint, optional: Max results to return
order_bylist of str, optional: Order by expression
page_tokenstr, optional: Previous page token, to start search from next page

Returns:

runs: Iterator of mlflow_rest_client.run.Run: Runs iterator

Examples

experiment_ids = [123]

for run in client.search_runs_iterator(experiment_ids):
    print(run)

query = "metrics.rmse < 1 and params.model_class = 'LogisticRegression'"
for run in client.search_runs_iterator(experiment_ids, query=query):
    print(run)

order_by = ["name", "version ASC"]
for run in client.search_runs_iterator(experiment_ids, order_by=order_by):
    print(run)

for run in client.search_runs_iterator(experiment_ids, run_view_type=RunViewType.ALL):
    print(run)

for run in client.search_runs_iterator(experiment_ids, max_results=100):
    print(run)

for run in client.search_runs_iterator(experiment_ids, page_token="next_page_id"):
    print(run)

set_experiment_tag(experiment_id, key, value)#

Set experiment tag

Return type:

None

Parameters:

experiment_idint: Experiment ID
keystr: Tag name
valuestr: Tag value

Examples

client.set_experiment_tag(123, "some.tag", "some.value")

set_model_description(name, description)#

Set model description

Return type:

Parameters:

namestr: Old model name
descriptionstr: New model description

Returns:

model: mlflow_rest_client.model.Model: Updated model

Examples

model = client.set_model_description("some_model", "new description")

set_model_tag(name, key, value)#

Set model tag

Return type:

None

Parameters:

namestr: Model name
keystr: Tag name
valuestr: Tag value

Examples

client.set_model_tag("some_model", "some.tag", "some.value")

set_model_version_description(name, version, description)#

Set model version description

Return type:

Parameters:

namestr: Old model name
version: int: Version number
descriptionstr: New model version description

Returns:

model_version: mlflow_rest_client.model.ModelVersion: Updated model version

Examples

model_version = client.set_model_version_description("some_model", 1, "new description")

set_model_version_tag(name, version, key, value)#

Set model version tag

Return type:

None

Parameters:

namestr: Model name
version: int: Version number
keystr: Tag name
valuestr: Tag value

Examples

client.set_model_version_tag("some_model", 1, "some.tag", "some.value")

set_run_status(run_id, status, end_time=None)#

Set run status

Return type:

Parameters:

run_idstr: Run ID
statusstr or mlflow_rest_client.run.RunStatus: Run status
end_timeint or datetime.datetime, optional: End time

Returns:

run_infomlflow_rest_client.run.Runinfo: Run info

Examples

run_info = client.set_run_status("some_run_id", "FAILED")
run_info = client.set_run_status("some_run_id", RunStatus.FAILED)
run_info = client.set_run_status(
    "some_run_id", RunStatus.FINISHED, end_time=datetime.datetime.now()
)

set_run_tag(run_id, key, value)#

Set run tag

Return type:

None

Parameters:

run_idUUID: Run ID
keystr: Tag name
valuestr: Tag value

Examples

client.set_run_tag("some_run_id", "some.tag", "some.value")

set_run_tags(run_id, tags)#

Set run tags

Return type:

None

Parameters:

run_idstr: Run ID
tags: :obj:`dict`, :obj:`list` of :obj:`dict`: Run tags list

Examples

run_tags = {"some": "tag"}
# or
run_tags = [{"key": "some", "value": "param"}]

client.set_run_tags("some_run_id", run_tags)

start_run(run_id)#

Change run status to STARTED

Return type:

Parameters:

run_idstr: Run ID

Returns:

run_infomlflow_rest_client.run.Runinfo: Run info

Examples

run_info = client.start_run("some_run_id")

test_model_version(name, version, **params)#

Change model version stage to Staging

Return type:

Parameters:

namestr: Model name
version: int: Version number
archive_existingbool, optional: If True, previous model versions should be archived

Returns:

model_versionmlflow_rest_client.model.ModelVersion: Updated model version

Examples

model_version = client.test_model_version("some_run_id", 1)
model_version = client.test_model_version("some_run_id", 1, archive_existing=True)

transition_model_version_stage(name, version, stage, archive_existing=False)#

Transition model version between stages

Return type: