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