def collect_model_metadata(model_uri, user_id, table):
_, model_name, model_version = model_uri.split("/")
client = MlflowClient()
model_metadata = client.get_model_version(model_name, model_version)
download_uri = client.get_model_version_download_uri(
model_name, model_version)
# Download the model and the associated metadata files locally
model_path = _download_artifact_from_uri(download_uri)
model_config_path = os.path.join(model_path, "MLmodel")
if not os.path.exists(model_config_path):
raise MlflowException(message=(
"Failed to find MLmodel configuration within the specified model's"
" root directory."),
error_code=INVALID_PARAMETER_VALUE)
model_config = Model.load(model_config_path)
flavor = _validate_deployment_flavor(model_config)
flavor_conf = _get_flavor_configuration(model_path=model_path,
flavor_name=flavor)
model_file = os.path.join(model_path, flavor_conf["data"])
return table(model_name=model_name,
model_version=model_version,
model_framework=flavor,
model_framework_version=flavor_conf[flavor + "_version"],
model=open(model_file, "rb").read(),
model_creation_time=datetime.fromtimestamp(
model_metadata.creation_timestamp / 1000),
model_deployment_time=datetime.now(),
deployed_by=user_id,
model_description=model_metadata.description,
run_id=model_metadata.run_id)
def wait_until_ready(model_name, model_version):
client = MlflowClient()
for _ in range(10):
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(1)
client.update_model_version(
name=registered_model.name,
version=registered_model.version,
description="This predicts the age of a customer using transaction history."
)
#Transition a model version to Staging/Prod/Archived
client.transition_model_version_stage(
name=registered_model.name,
version=registered_model.version,
stage='Staging',
)
#Get model version details
model_version = client.get_model_version(
name=registered_model.name,
version=registered_model.version,
)
#Load a specific model version from the Model Registry
model_uri = "models:/{model_name}/staging".format(model_name=model_name)
spark_model = mlflow.spark.load_model(model_uri)
# COMMAND ----------
# MAGIC %md ##3. ML Model Serving and Inferencing
# MAGIC ###Offline Inferencing
# COMMAND ----------
import mlflow
# MAGIC %md ## Read new model version
# COMMAND ----------
client = MlflowClient()
model_udf = mlflow.pyfunc.spark_udf(spark,
f"models:/{model_name}/{model_version}")
# COMMAND ----------
# MAGIC %md ## Model's stage should be None or Staging, if not then we're using the wrong model version
# COMMAND ----------
current_stage = client.get_model_version(model_name,
model_version).current_stage
if current_stage in ["Production", "Archived"]:
raise Exception(
f"Bad current stage '{current_stage}' for model version {model_version}. Should be None or Staging."
)
# COMMAND ----------
# MAGIC %md ## Make predictions on test data
# COMMAND ----------
data = spark.read.format("delta").load(input_data_path)
preds = data.withColumn(
"prediction", model_udf(*data.drop("quality").columns)).select(
"quality",
description="This model forecasts the wine quality based on the characteristics."
)
client.update_model_version(
name=model_name,
version=model_version,
description="This model version was built using sklearn."
)
# COMMAND ----------
client.transition_model_version_stage(
name=model_name,
version=model_version,
stage=stage,
archive_existing_versions=True
)
model_version_details = client.get_model_version(
name=model_name,
version=model_version,
)
print("The current model stage is: '{stage}'".format(stage=model_version_details.current_stage))
latest_version_info = client.get_latest_versions(model_name, stages=[stage])
latest_production_version = latest_version_info[0].version
print("The latest production version of the model '%s' is '%s'." % (model_name, latest_production_version))
# COMMAND ----------
dbutils.notebook.exit()
