def downloadPickles(ws, modelName, outputPath="./pickles", modelVer=None):
if modelVer == 'best':
bestModel = None
maxAcc = -1
for model in Model.list(ws, modelName, ["accuracy"]):
modelAcc = float(model.tags["accuracy"])
if modelAcc > maxAcc:
bestModel = model
maxAcc = modelAcc
print(f"### Best model with highest accuracy of {maxAcc} found")
if not bestModel:
model = Model(ws, modelName)
print("### WARNING! No best model found, using latest instead")
elif modelVer is not None:
model = Model(ws, modelName, version=modelVer)
else:
model = Model(ws, modelName)
print(f"### Using model version {model.version}")
# Echo'ing out this magic string sets an output variable in Azure DevOps pipeline
# Set AZML_MODEL_VER for use by subsequent steps
print(f"##vso[task.setvariable variable=AZML_MODEL_VER]{model.version}")
# These are special tags, lets us get back to the run that created the model
try:
runId = model.tags['aml-runid']
experimentName = model.tags['aml-experiment']
except:
print(
"### ERROR! Model missing `aml-runid` and `aml-experiment` tags, Can't continue!"
)
exit()
exp = Experiment(workspace=ws, name=experimentName)
run = Run(exp, runId)
if run.status != "Completed":
print(f'### ERROR! Run {runId} did not complete!')
return
print(f'### Will download from run {runId} in {experimentName}')
# Now we can get all the files created with the run, grab all the .pkls
for f in run.get_file_names():
if f.endswith('.pkl'):
output_file_path = os.path.join(outputPath, f.split('/')[-1])
print('### Downloading from {} to {} ...'.format(
f, output_file_path))
run.download_file(name=f, output_file_path=output_file_path)
# Add some extra metadata, handy to have
metadata = {
'name': model.name,
'version': model.version,
'tags': model.tags
}
with open(f"{outputPath}/metadata.json", 'w') as metadata_file:
print(f"### Storing metadata in {outputPath}/metadata.json")
json.dump(metadata, metadata_file)
def download_run_outputs_by_prefix(
blobs_prefix: Path, destination: Path, run: Run
) -> None:
"""
Download all the blobs from the run's default output directory: DEFAULT_AML_UPLOAD_DIR ("outputs") that
have a given prefix (folder structure). When saving, the prefix string will be stripped off. For example,
if blobs_prefix = "foo", and the run has a file "outputs/foo/bar.csv", it will be downloaded to destination/bar.csv.
If there is in addition a file "foo.txt", that file will be skipped.
:param blobs_prefix: The prefix for all files in "outputs" that should be downloaded.
:param run: The AzureML run to download the files from.
:param destination: Local path to save the downloaded blobs to.
"""
prefix_str = str((fixed_paths.DEFAULT_AML_UPLOAD_DIR / blobs_prefix).as_posix())
logging.info(
f"Downloading multiple files from run {run.id}: {prefix_str} -> {str(destination)}"
)
# There is a download_files function, but that can time out when downloading several large checkpoints file
# (120sec timeout for all files).
for file in run.get_file_names():
if file.startswith(prefix_str):
target_path = file[len(prefix_str):]
if target_path.startswith("/"):
target_path = target_path[1:]
logging.info(f"Downloading {file}")
run.download_file(
file, str(destination / target_path), _validate_checksum=True
)
else:
logging.warning(
f"Skipping file {file}, because the desired prefix {prefix_str} is not aligned with "
f"the folder structure"
)
def download_model_file(run_id: str, remote_file: str, local_file: str) -> None:
"""Download the model.pt file for the corresponding run_id to the local
directory. Then it is uploaded to Azure when run. Could be other ways
to acomplish this (copy directly from run to run perhaps)"""
ws = Workspace.from_config()
experiment = Experiment(workspace=ws, name="hm-2016")
run = Run(experiment, run_id)
print(model_file)
run.download_file(remote_file, local_file)
def download_model(workspace, experiment_name, run_id, input_location,
output_location):
"""
Download the pretrained model
Input:
workspace: workspace to access the experiment
experiment_name: Name of the experiment in which model is saved
run_id: Run Id of the experiment in which model is pre-trained
input_location: Input location in a RUN Id
output_location: Location for saving the model
"""
experiment = Experiment(workspace=workspace, name=experiment_name)
#Download the model on which evaluation need to be done
run = Run(experiment, run_id=run_id)
#run.get_details()
run.download_file(input_location, output_location)
logger.info("Successfully downloaded model")
def get_job_log_file(run: Run, index: Optional[int] = None) -> str:
"""
Reads the job log file (70_driver_log.txt or std_log.txt) of the given job. If an index is provided, get
the matching file from a multi-node job.
:return: The contents of the job log file.
"""
assert run.status == RunStatus.COMPLETED
files = run.get_file_names()
suffix = (f"_{index}" if index is not None else "") + ".txt"
file1 = "azureml-logs/70_driver_log" + suffix
file2 = "user_logs/std_log" + suffix
if file1 in files:
file = file1
elif file2 in files:
file = file2
else:
raise ValueError(f"No log file ({file1} or {file2}) present in the run. Existing files: {files}")
downloaded = tempfile.NamedTemporaryFile().name
run.download_file(name=file, output_file_path=downloaded)
return Path(downloaded).read_text()
def download_model(ws, experiment_name, run_id, input_location, output_location):
"""Download the pretrained model
Args:
ws: workspace to access the experiment
experiment_name: Name of the experiment in which model is saved
run_id: Run Id of the experiment in which model is pre-trained
input_location: Input location in a RUN Id
output_location: Location for saving the model
"""
experiment = Experiment(workspace=ws, name=experiment_name)
# Download the model on which evaluation need to be done
run = Run(experiment, run_id=run_id)
if input_location.endswith(".h5"):
run.download_file(input_location, output_location)
elif input_location.endswith(".ckpt"):
run.download_files(prefix=input_location,
output_directory=output_location)
else:
raise NameError(f"{input_location}'s path extension not supported")
print("Successfully downloaded model")
def download_run_output_file(blob_path: Path, destination: Path, run: Run) -> Path:
"""
Downloads a single file from the run's default output directory: DEFAULT_AML_UPLOAD_DIR ("outputs").
For example, if blobs_path = "foo/bar.csv", then the run result file "outputs/foo/bar.csv" will be downloaded
to <destination>/bar.csv (the directory will be stripped off).
:param blob_path: The name of the file to download.
:param run: The AzureML run to download the files from
:param destination: Local path to save the downloaded blob to.
:return: Destination path to the downloaded file(s)
"""
blobs_prefix = str((fixed_paths.DEFAULT_AML_UPLOAD_DIR / blob_path).as_posix())
destination = destination / blob_path.name
logging.info(
f"Downloading single file from run {run.id}: {blobs_prefix} -> {str(destination)}"
)
try:
run.download_file(blobs_prefix, str(destination), _validate_checksum=True)
except Exception as ex:
raise ValueError(
f"Unable to download file '{blobs_prefix}' from run {run.id}"
) from ex
return destination
sys.exit(0)
run_id = config["run_id"]
experiment_name = config["experiment_name"]
exp = Experiment(workspace=ws, name=experiment_name)
run = Run(experiment=exp, run_id=run_id)
names = run.get_file_names
names()
print("Run ID for last run: {}".format(run_id))
model_local_dir = "model"
os.makedirs(model_local_dir, exist_ok=True)
# Download Model to Project root directory
model_name = "arima_model.pkl"
run.download_file(name="./outputs/" + model_name,
output_file_path="./model/" + model_name)
print("Downloaded model {} to Project root directory".format(model_name))
os.chdir("./model")
model = Model.register(
model_path=model_name, # this points to a local file
model_name=model_name, # this is the name the model is registered as
tags={
"area": "robberies",
"type": "forecasting",
"run_id": run_id
},
description="Time series forecasting model for Adventure Works dataset",
workspace=ws,
)
os.chdir("..")
print(
minimum_rmse_runid = None
minimum_rmse = None
for run in experiment.get_runs():
run_metrics = run.get_metrics()
run_details = run.get_details()
# each logged metric becomes a key in this returned dict
run_rmse = run_metrics["rmse"]
run_id = run_details["runId"]
if minimum_rmse is None:
minimum_rmse = run_rmse
minimum_rmse_runid = run_id
else:
if run_rmse < minimum_rmse:
minimum_rmse = run_rmse
minimum_rmse_runid = run_id
print("Best run_id: " + minimum_rmse_runid)
print("Best run_id rmse: " + str(minimum_rmse))
from azureml.core import Run
best_run = Run(experiment=experiment, run_id=minimum_rmse_runid)
print(best_run.get_file_names())
best_run.download_file(name="model_alpha_0.1.pkl")
model = best_run.register_model(model_name='diabetes',
model_path='model_alpha_0.1.pkl')
print(model.name, model.id, model.version, sep='\t')
run_details = run.get_details()
# each logged metric becomes a key in this returned dict
run_rmse = run_metrics["rmse"]
run_id = run_details["runId"]
if minimum_rmse is None:
minimum_rmse = run_rmse
minimum_rmse_runid = run_id
else:
if run_rmse < minimum_rmse:
minimum_rmse = run_rmse
minimum_rmse_runid = run_id
#Sobre el mejor modelo, obtener una referencia del mismo
from azureml.core import Run
best_run = Run(experiment=experiment, run_id=minimum_rmse_runid)
print(best_run.get_file_names())
#Descargar el modelo
model_file_name = best_run.get_file_names()[0]
best_run.download_file(name=model_file_name)
#Cargamos el modelo en python
import joblib
clf = joblib.load(model_file_name)
print("El proceso ha finalizado correctamente!!")
#Uso del clasificador para nuevos datos (referencia)
#y_predecido = clf.predict(X)
#Comparar x con y y calcular rmse
#rmse = math.sqrt(mean_squared_error(y_true=y_realdelosdatos, y_pred=y_predecido))
from azureml.automl.core.shared.constants import MODEL_PATH
train_experiment_name = '<<train_experiment_name>>'
train_run_id = '<<train_run_id>>'
target_column_name = '<<target_column_name>>'
test_dataset_name = '<<test_dataset_name>>'
run = Run.get_context()
ws = run.experiment.workspace
# Get the AutoML run object from the experiment name and the workspace
train_experiment = Experiment(ws, train_experiment_name)
automl_run = Run(experiment=train_experiment, run_id=train_run_id)
# Download the trained model from the artifact store
automl_run.download_file(name=MODEL_PATH, output_file_path='model.pkl')
# get the input dataset by name
test_dataset = Dataset.get_by_name(ws, name=test_dataset_name)
X_test_df = test_dataset.drop_columns(
columns=[target_column_name]).to_pandas_dataframe().reset_index(drop=True)
y_test_df = test_dataset.with_timestamp_columns(None).keep_columns(
columns=[target_column_name]).to_pandas_dataframe()
fitted_model = joblib.load('model.pkl')
y_pred, X_trans = fitted_model.rolling_evaluation(X_test_df, y_test_df.values)
# Add predictions, actuals, and horizon relative to rolling origin to the test feature data
assign_dict = {
print("run_id:", run_id)
print("experiment name:", experiment_name)
print("ws:", ws)
exp = Experiment(workspace=ws, name=experiment_name)
run = Run(experiment=exp, run_id=run_id)
names = run.get_file_names
names()
print('Run ID for last run: {}'.format(run_id))
model_local_dir = "model"
os.makedirs(model_local_dir, exist_ok=True)
# Download Model to Project root directory
model_name = 'model.pkl'
run.download_file(name='./outputs/' + model_name,
output_file_path='./model/' + model_name)
print('Downloaded model {} to Project root directory'.format(model_name))
os.chdir('./model')
model = Model.register(
model_path=model_name, # this points to a local file
model_name=model_name, # this is the name the model is registered as
tags={
'area': "predictive maintenance",
'type': "automl",
'run_id': run_id
},
description="Model for predictive maintenance dataset",
workspace=ws)
os.chdir('..')
print(
'Model registered: {} \nModel Description: {} \nModel Version: {}'.format(
sys.exit(0)
run_id = config["run_id"]
experiment_name = config["experiment_name"]
exp = Experiment(workspace = ws, name = experiment_name)
run = Run(experiment = exp, run_id = run_id)
names=run.get_file_names
names()
print('Run ID for last run: {}'.format(run_id))
model_local_dir="./model"
os.makedirs(model_local_dir,exist_ok=True)
# Download Model to Project root directory
model_name= 'sklearn_regression_model.pkl'
run.download_file(name = './outputs/'+model_name,
output_file_path = model_local_dir+model_name)
print('Downloaded model {} to Project root directory'.format(model_name))
model = Model.register(model_path = model_local_dir+model_name, # this points to a local file
model_name = model_name, # this is the name the model is registered as
tags = {'area': "diabetes", 'type': "regression", 'run_id' : run_id},
description="Regression model for diabetes dataset",
workspace = ws)
print('Model registered: {} \nModel Description: {} \nModel Version: {}'.format(model.name, model.description, model.version))
# Remove the evaluate.json as we no longer need it
# os.remove("aml_config/evaluate.json")
# Writing the registered model details to /aml_config/model.json
model_json = {}
cli_auth = AzureCliAuthentication()
# Get workspace
ws = Workspace.from_config(auth=cli_auth)
# Get the latest evaluation result
try:
with open("run_id.json") as f:
config = json.load(f)
if not config["run_id"]:
raise Exception(
"No new model to register as production model perform better")
except:
print("No new model to register as production model perform better")
# raise Exception('No new model to register as production model perform better')
sys.exit(0)
run_id = config["run_id"]
experiment_name = config["experiment_name"]
exp = Experiment(workspace=ws, name=experiment_name)
run = Run(experiment=exp, run_id=run_id)
os.makedirs('../mnist-tf/ckpt', exist_ok=True)
for f in run.get_file_names():
if f.startswith('outputs/model'):
output_file_path = os.path.join('../mnist-tf/ckpt/', f.split('/')[-1])
print('Downloading from {} to {} ...'.format(f, output_file_path))
run.download_file(name=f, output_file_path=output_file_path)
filename = "finalmodel2.pkl"
joblib.dump(value=model, filename='finalmodel2.pkl')
run.upload_file(name=model_name, path_or_stream=filename)
run.complete()
from azureml.core import Run
runid='062ae84f-1f94-43ed-bcf5-377a93b14006'
run = Run(experiment=experiment, run_id=runid)
print(run.get_file_names())
# Change names
run.download_file(name="finalmodel2.pkl")
model = run.register_model(model_name='finalmodel2.pkl',
model_path='finalmodel2.pkl')
print(model.name, model.id, model.version, sep='\t')
aml_location = 'outputs/{0}'.format(saved_model_name)
user_folder = '/dbfs/tmp/{0}/'.format(user_name)
# Create objects with folder names
temporary_zip_path = os.path.join(
user_folder, 'trained_model_zip') # Folder to zipped model file
temporary_model_path = os.path.join(
user_folder, 'trained_model') # Folder for unzipped model files
# Make the temporary directories
os.makedirs(temporary_zip_path, exist_ok=True)
os.makedirs(temporary_model_path, exist_ok=True)
# Download the zip file from AML service to the 'trained_model_zip' folder
best_run.download_file(aml_location, temporary_zip_path)
# Unpack archive to the 'trained_model' folder
shutil.unpack_archive(os.path.join(temporary_zip_path, saved_model_name),
temporary_model_path)
# COMMAND ----------
# MAGIC %md
# MAGIC ### Register the model to AML service
# MAGIC
# MAGIC In order to deploy a model in AML - we will 'register' a model with the service. This allows us for model traceability in the service.
# MAGIC
# MAGIC There are 3 different pieces of deploying an AML model.
# MAGIC 1. `Model` objects store the model files for scoring and metadata about the model
# MAGIC 1. `Image` objects refer to Docker images that were built with a registered `model`
