def _parse_model_ref(parsed: ParseResult, client: MlflowClient):
model = parsed.hostname
path = parsed.path.lstrip("/")
if path.isdigit():
mv = client.get_model_version(model, int(path))
run = client.get_run(mv.run_id)
return (
"models:/{}/{}".format(model, path),
run.data.tags,
run.data.params,
)
if not path:
stage = "none" # TODO allow setting default stage from config
else:
stage = path.lower()
results = client.get_latest_versions(model, stages=[stage])
if not results:
raise SpecError(
"No versions found for model {} in stage {}".format(model, stage)
)
run = client.get_run(results[0].run_id)
return (
"models:/{}/{}".format(model, results[0].version),
run.data.tags,
run.data.params,
)
def wait_until_ready(model_name, model_version):
client = MlflowClient(registry_uri=cmr_uri)
for _ in range(20):
model_version_details = client.get_model_version(
name=model_name,
version=model_version,
)
status = ModelVersionStatus.from_string(model_version_details.status)
print("Model status: %s" % ModelVersionStatus.to_string(status))
if status == ModelVersionStatus.READY:
break
time.sleep(5)
def test_client_registry_operations_raise_exception_with_unsupported_registry_store():
"""
This test case ensures that Model Registry operations invoked on the `MlflowClient`
fail with an informative error message when the registry store URI refers to a
store that does not support Model Registry features (e.g., FileStore).
"""
with TempDir() as tmp:
client = MlflowClient(registry_uri=tmp.path())
expected_failure_functions = [
client._get_registry_client,
lambda: client.create_registered_model("test"),
lambda: client.get_registered_model("test"),
lambda: client.create_model_version("test", "source", "run_id"),
lambda: client.get_model_version("test", 1),
]
for func in expected_failure_functions:
with pytest.raises(MlflowException) as exc:
func()
assert exc.value.error_code == ErrorCode.Name(FEATURE_DISABLED)
print("Name: {}".format(mv.name))
print("Version: {}".format(mv.version))
print("Tags: {}".format(mv.tags))
mlflow.set_tracking_uri("sqlite:///mlruns.db")
params = {"n_estimators": 3, "random_state": 42}
name = "RandomForestRegression"
rfr = RandomForestRegressor(**params).fit([[0, 1]], [1])
# Log MLflow entities
with mlflow.start_run() as run:
mlflow.log_params(params)
mlflow.sklearn.log_model(rfr, artifact_path="sklearn-model")
# Register model name in the model registry
client = MlflowClient()
client.create_registered_model(name)
# Create a new version of the rfr model under the registered model name
# and delete a tag
model_uri = "runs:/{}/sklearn-model".format(run.info.run_id)
tags = {'t': "t1"}
mv = client.create_model_version(name,
model_uri,
run.info.run_id,
tags=tags)
print_model_version_info(mv)
print("--")
client.delete_model_version_tag(name, mv.version, "t")
mv = client.get_model_version(name, mv.version)
print_model_version_info(mv)
# COMMAND ----------
client = MlflowClient(tracking_uri=None, registry_uri=registry_uri)
model_names = [m.name for m in client.list_registered_models() if m.name.startswith('Air')]
print(model_names)
# COMMAND ----------
client.update_registered_model(model_name, description='For ranking')
# COMMAND ----------
client.transition_model_version_stage(model_name, 1, 'Staging')
client.get_model_version(model_name, 1)
# COMMAND ----------
from mlflow.tracking import MlflowClient
client = MlflowClient()
experiment_id = '3181692072700047'
runs_df = mlflow.search_runs(experiment_id)
display(runs_df)
# COMMAND ----------
df_client = spark.read.format("mlflow-experiment").load("3181692072700047")
df_client.createOrReplaceTempView("airbnb_model")
