Dec 2020

https://docs.microsoft.com/en-us/learn/paths/build-ai-solutions-with-azure-ml-service/

https://github.com/MicrosoftLearning/mslearn-dp100

https://microsoftlearning.github.io/mslearn-dp100

Go to https://ml.azure.com/

Create a Compute instance (Standard D12 v2)

Notebooks -> Terminal

cd Users

git clone https://github.com/MicrosoftLearning/mslearn-dp100

Refresh the file pane to see the folder

01 Getting started

https://github.com/MicrosoftLearning/mslearn-dp100/blob/main/01%20-%20Get%20Started%20with%20Notebooks.ipynb

The config file is in the root dir

from azureml.core import Workspace

ws = Workspace.from_config()

See compute targets

from azureml.core import ComputeTarget

print("Compute Resources:")

for compute_name in ws.compute_targets:

compute = ws.compute_targets[compute_name]

print("\t", compute.name, ':', compute.type)

Write a scipt

from azureml.core import Run

import pandas as pd

import numpy as np

import joblib

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

# Get the experiment run context

run = Run.get_context()

# Prepare the dataset

diabetes = pd.read_csv('data.csv')

X, y = data[['Feature1','Feature2','Feature3']].values, data['Label'].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)

# Train a logistic regression model

reg = 0.1

model = LogisticRegression(C=1/reg, solver="liblinear").fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

run.log('Accuracy', np.float(acc))

# Save the trained model

os.makedirs('outputs', exist_ok=True)

joblib.dump(value=model, filename='outputs/model.pkl')

run.complete()

Run the script

from azureml.core import Experiment, ScriptRunConfig, Environment

from azureml.core.conda_dependencies import CondaDependencies

# Create a Python environment for the experiment

sklearn_env = Environment("sklearn-env")

# Ensure the required packages are installed

packages = CondaDependencies.create(conda_packages=['scikit-learn','pip'],

pip_packages=['azureml-defaults'])

sklearn_env.python.conda_dependencies = packages

# Create a script config

script_config = ScriptRunConfig(source_directory='training_folder',

script='training.py',

environment=sklearn_env)

# Submit the experiment

experiment = Experiment(workspace=ws, name='training-experiment')

run = experiment.submit(config=script_config)

run.wait_for_completion()

For hyperparamters

from azureml.core import Run

import argparse

import pandas as pd

import numpy as np

import joblib

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

# Get the experiment run context

run = Run.get_context()

# Set regularization hyperparameter

parser = argparse.ArgumentParser()

parser.add_argument('--reg-rate', type=float, dest='reg_rate', default=0.01)

args = parser.parse_args()

reg = args.reg_rate

# Prepare the dataset

diabetes = pd.read_csv('data.csv')

X, y = data[['Feature1','Feature2','Feature3']].values, data['Label'].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)

# Train a logistic regression model

model = LogisticRegression(C=1/reg, solver="liblinear").fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

run.log('Accuracy', np.float(acc))

# Save the trained model

os.makedirs('outputs', exist_ok=True)

joblib.dump(value=model, filename='outputs/model.pkl')

run.complete()

Passing arguments into a script

# Create a script config

script_config = ScriptRunConfig(source_directory='training_folder',

script='training.py',

arguments = ['--reg-rate', 0.1],

environment=sklearn_env)

Register models

You can download the model to local

# "run" is a reference to a completed experiment run

# List the files generated by the experiment

for file in run.get_file_names():

print(file)

# Download a named file

run.download_file(name='outputs/model.pkl', output_file_path='model.pkl')

Register

from azureml.core import Model

model = Model.register(workspace=ws,

model_name='classification_model',

model_path='model.pkl', # local path

description='A classification model',

tags={'data-format': 'CSV'},

model_framework=Model.Framework.SCIKITLEARN,

model_framework_version='0.20.3')

or

run.register_model( model_name='classification_model',

model_path='outputs/model.pkl', # run outputs path

description='A classification model',

tags={'data-format': 'CSV'},

model_framework=Model.Framework.SCIKITLEARN,

model_framework_version='0.20.3')

See registered models

from azureml.core import Model

for model in Model.list(ws):

# Get model name and auto-generated version

print(model.name, 'version:', model.version)

Go thorugh https://github.com/MicrosoftLearning/mslearn-dp100/blob/main/05%20-%20Train%20Models.ipynb

!pip install --upgrade azureml-sdk azureml-widgets

import azureml.core

from azureml.core import Workspace

# Load the workspace from the saved config file

ws = Workspace.from_config()

print('Ready to use Azure ML {} to work with {}'.format(azureml.core.VERSION, ws.name))

import os, shutil

# Create a folder for the experiment files

training_folder = 'diabetes-training'

os.makedirs(training_folder, exist_ok=True)

# Copy the data file into the experiment folder

shutil.copy('data/diabetes.csv', os.path.join(training_folder, "diabetes.csv"))

Write training script

%%writefile $training_folder/diabetes_training.py

# Import libraries

from azureml.core import Run

import pandas as pd

import numpy as np

import joblib

import os

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

# Get the experiment run context

run = Run.get_context()

# load the diabetes dataset

print("Loading Data...")

diabetes = pd.read_csv('diabetes.csv')

# Separate features and labels

X, y = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].values, diabetes['Diabetic'].values

# Split data into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)

# Set regularization hyperparameter

reg = 0.01

# Train a logistic regression model

print('Training a logistic regression model with regularization rate of', reg)

run.log('Regularization Rate', np.float(reg))

model = LogisticRegression(C=1/reg, solver="liblinear").fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

print('Accuracy:', acc)

run.log('Accuracy', np.float(acc))

# calculate AUC

y_scores = model.predict_proba(X_test)

auc = roc_auc_score(y_test,y_scores[:,1])

print('AUC: ' + str(auc))

run.log('AUC', np.float(auc))

# Save the trained model in the outputs folder

os.makedirs('outputs', exist_ok=True)

joblib.dump(value=model, filename='outputs/diabetes_model.pkl')

run.complete()

Run the script

from azureml.core import Experiment, ScriptRunConfig, Environment

from azureml.core.conda_dependencies import CondaDependencies

from azureml.widgets import RunDetails

# Create a Python environment for the experiment

sklearn_env = Environment("sklearn-env")

# Ensure the required packages are installed (we need scikit-learn and Azure ML defaults)

packages = CondaDependencies.create(pip_packages=['scikit-learn','azureml-defaults'])

sklearn_env.python.conda_dependencies = packages

# Create a script config

script_config = ScriptRunConfig(source_directory=training_folder,

script='diabetes_training.py',

environment=sklearn_env)

# submit the experiment run

experiment_name = 'mslearn-train-diabetes'

experiment = Experiment(workspace=ws, name=experiment_name)

run = experiment.submit(config=script_config)

# Show the running experiment run in the notebook widget

RunDetails(run).show()

# Block until the experiment run has completed

run.wait_for_completion()

Retrive metrics and output

# Get logged metrics and files

metrics = run.get_metrics()

for key in metrics.keys():

print(key, metrics.get(key))

print('\n')

for file in run.get_file_names():

print(file)

Register the model

from azureml.core import Model

# Register the model

run.register_model(model_path='outputs/diabetes_model.pkl', model_name='diabetes_model',

tags={'Training context':'Script'},

properties={'AUC': run.get_metrics()['AUC'], 'Accuracy': run.get_metrics()['Accuracy']})

# List registered models

for model in Model.list(ws):

print(model.name, 'version:', model.version)

for tag_name in model.tags:

tag = model.tags[tag_name]

print ('\t',tag_name, ':', tag)

for prop_name in model.properties:

prop = model.properties[prop_name]

print ('\t',prop_name, ':', prop)

print('\n')

Create folder for param script and training data

import os, shutil

# Create a folder for the experiment files

training_folder = 'diabetes-training-params'

os.makedirs(training_folder, exist_ok=True)

# Copy the data file into the experiment folder

shutil.copy('data/diabetes.csv', os.path.join(training_folder, "diabetes.csv"))

Write file

%%writefile $training_folder/diabetes_training.py

# Import libraries

from azureml.core import Run

import pandas as pd

import numpy as np

import joblib

import os

import argparse

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

# Get the experiment run context

run = Run.get_context()

# Set regularization hyperparameter

parser = argparse.ArgumentParser()

parser.add_argument('--reg_rate', type=float, dest='reg', default=0.01)

args = parser.parse_args()

reg = args.reg

# load the diabetes dataset

print("Loading Data...")

# load the diabetes dataset

diabetes = pd.read_csv('diabetes.csv')

# Separate features and labels

X, y = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].values, diabetes['Diabetic'].values

# Split data into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)

# Train a logistic regression model

print('Training a logistic regression model with regularization rate of', reg)

run.log('Regularization Rate', np.float(reg))

model = LogisticRegression(C=1/reg, solver="liblinear").fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

print('Accuracy:', acc)

run.log('Accuracy', np.float(acc))

# calculate AUC

y_scores = model.predict_proba(X_test)

auc = roc_auc_score(y_test,y_scores[:,1])

print('AUC: ' + str(auc))

run.log('AUC', np.float(auc))

os.makedirs('outputs', exist_ok=True)

joblib.dump(value=model, filename='outputs/diabetes_model.pkl')

run.complete()

Run the script with arguments

# Create a script config

script_config = ScriptRunConfig(source_directory=training_folder,

script='diabetes_training.py',

arguments = ['--reg_rate', 0.1],

environment=sklearn_env)

# submit the experiment

experiment_name = 'mslearn-train-diabetes'

experiment = Experiment(workspace=ws, name=experiment_name)

run = experiment.submit(config=script_config)

RunDetails(run).show()

run.wait_for_completion()

Get output

# Get logged metrics

metrics = run.get_metrics()

for key in metrics.keys():

print(key, metrics.get(key))

print('\n')

for file in run.get_file_names():

print(file)

Register new version

from azureml.core import Model

# Register the model

run.register_model(model_path='outputs/diabetes_model.pkl', model_name='diabetes_model',

tags={'Training context':'Parameterized script'},

properties={'AUC': run.get_metrics()['AUC'], 'Accuracy': run.get_metrics()['Accuracy']})

# List registered models

for model in Model.list(ws):

print(model.name, 'version:', model.version)

for tag_name in model.tags:

tag = model.tags[tag_name]

print ('\t',tag_name, ':', tag)

for prop_name in model.properties:

prop = model.properties[prop_name]

print ('\t',prop_name, ':', prop)

print('\n')

You can see the Models in the Models section under Assets

Work with Data in Azure Machine Learning

Mount a blob

from azureml.core import Workspace, Datastore

ws = Workspace.from_config()

# Register a new datastore

blob_ds = Datastore.register_azure_blob_container(workspace=ws,

datastore_name='blob_data',

container_name='data_container',

account_name='az_store_acct',

account_key='123456abcde789…')

View data stores

for ds_name in ws.datastores:

print(ds_name)

Get a reference using get

blob_store = Datastore.get(ws, datastore_name='blob_data')

Has a default (built in workspaceblobsore datastore)

default_store = ws.get_default_datastore()

Change the name of the default store

ws.set_default_datastore('blob_data')

Create and register tabular datasets

from azureml.core import Dataset

blob_ds = ws.get_default_datastore()

csv_paths = [(blob_ds, 'data/files/current_data.csv'),

(blob_ds, 'data/files/archive/*.csv')]

tab_ds = Dataset.Tabular.from_delimited_files(path=csv_paths)

tab_ds = tab_ds.register(workspace=ws, name='csv_table')

file datasets

from azureml.core import Dataset

blob_ds = ws.get_default_datastore()

file_ds = Dataset.File.from_files(path=(blob_ds, 'data/files/images/*.jpg'))

file_ds = file_ds.register(workspace=ws, name='img_files')

Get dataset

import azureml.core

from azureml.core import Workspace, Dataset

# Load the workspace from the saved config file

ws = Workspace.from_config()

# Get a dataset from the workspace datasets collection

ds1 = ws.datasets['csv_table']

# Get a dataset by name from the datasets class

ds2 = Dataset.get_by_name(ws, 'img_files')

Version dataset by adding create_new_version

img_paths = [(blob_ds, 'data/files/images/*.jpg'),

(blob_ds, 'data/files/images/*.png')]

file_ds = Dataset.File.from_files(path=img_paths)

file_ds = file_ds.register(workspace=ws, name='img_files', create_new_version=True)

Retrive a specific version

img_ds = Dataset.get_by_name(workspace=ws, name='img_files', version=2)

Convert to dataframe

df = tab_ds.to_pandas_dataframe()

# code to work with dataframe goes here, for example:

print(df.head())

Pass dataset to script use --ds

env = Environment('my_env')

packages = CondaDependencies.create(conda_packages=['pip'],

pip_packages=['azureml-defaults',

'azureml-dataprep[pandas]'])

env.python.conda_dependencies = packages

script_config = ScriptRunConfig(source_directory='my_dir',

script='script.py',

arguments=['--ds', tab_ds],

environment=env)

from azureml.core import Run, Dataset

parser.add_argument('--ds', type=str, dest='dataset_id')

args = parser.parse_args()

run = Run.get_context()

ws = run.experiment.workspace

dataset = Dataset.get_by_id(ws, id=args.dataset_id)

data = dataset.to_pandas_dataframe()

use a named input

env = Environment('my_env')

packages = CondaDependencies.create(conda_packages=['pip'],

pip_packages=['azureml-defaults',

'azureml-dataprep[pandas]'])

env.python.conda_dependencies = packages

script_config = ScriptRunConfig(source_directory='my_dir',

script='script.py',

arguments=['--ds', tab_ds.as_named_input('my_dataset')],

environment=env)

from azureml.core import Run

parser.add_argument('--ds', type=str, dest='ds_id')

args = parser.parse_args()

run = Run.get_context()

dataset = run.input_datasets['my_dataset']

data = dataset.to_pandas_dataframe()

Pass file dataset. Use as_download or as_mount for really large datasets

env = Environment('my_env')

packages = CondaDependencies.create(conda_packages=['pip'],

pip_packages=['azureml-defaults',

'azureml-dataprep[pandas]'])

env.python.conda_dependencies = packages

script_config = ScriptRunConfig(source_directory='my_dir',

script='script.py',

arguments=['--ds', file_ds.as_download()],

environment=env)

from azureml.core import Run

import glob

parser.add_argument('--ds', type=str, dest='ds_ref')

args = parser.parse_args()

run = Run.get_context()

imgs = glob.glob(ds_ref + "/*.jpg")

Use named input

env = Environment('my_env')

packages = CondaDependencies.create(conda_packages=['pip'],

pip_packages=['azureml-defaults',

'azureml-dataprep[pandas]'])

env.python.conda_dependencies = packages

script_config = ScriptRunConfig(source_directory='my_dir',

script='script.py',

arguments=['--ds', file_ds.as_named_input('my_ds').as_download()],

environment=env)

from azureml.core import Run

import glob

parser.add_argument('--ds', type=str, dest='ds_ref')

args = parser.parse_args()

run = Run.get_context()

dataset = run.input_datasets['my_ds']

imgs= glob.glob(dataset + "/*.jpg")

Go through https://github.com/MicrosoftLearning/mslearn-dp100/blob/main/06%20-%20Work%20with%20Data.ipynb

!pip install --upgrade azureml-sdk azureml-widgets

import azureml.core

from azureml.core import Workspace

# Load the workspace from the saved config file

ws = Workspace.from_config()

print('Ready to use Azure ML {} to work with {}'.format(azureml.core.VERSION, ws.name))

View datastores

# Get the default datastore

default_ds = ws.get_default_datastore()

# Enumerate all datastores, indicating which is the default

for ds_name in ws.datastores:

print(ds_name, "- Default =", ds_name == default_ds.name)

Upload data to datastore

default_ds.upload_files(files=['./data/diabetes.csv', './data/diabetes2.csv'], # Upload the diabetes csv files in /data

target_path='diabetes-data/', # Put it in a folder path in the datastore

overwrite=True, # Replace existing files of the same name

show_progress=True)

Create a tabular dataset

from azureml.core import Dataset

# Get the default datastore

default_ds = ws.get_default_datastore()

#Create a tabular dataset from the path on the datastore (this may take a short while)

tab_data_set = Dataset.Tabular.from_delimited_files(path=(default_ds, 'diabetes-data/*.csv'))

# Display the first 20 rows as a Pandas dataframe

tab_data_set.take(20).to_pandas_dataframe()

File dataset

#Create a file dataset from the path on the datastore (this may take a short while)

file_data_set = Dataset.File.from_files(path=(default_ds, 'diabetes-data/*.csv'))

# Get the files in the dataset

for file_path in file_data_set.to_path():

print(file_path)

Register the tabular dataset and the file dataset

# Register the tabular dataset

try:

tab_data_set = tab_data_set.register(workspace=ws,

name='diabetes dataset',

description='diabetes data',

tags = {'format':'CSV'},

create_new_version=True)

except Exception as ex:

print(ex)

# Register the file dataset

try:

file_data_set = file_data_set.register(workspace=ws,

name='diabetes file dataset',

description='diabetes files',

tags = {'format':'CSV'},

create_new_version=True)

except Exception as ex:

print(ex)

print('Datasets registered')

View the registered datasets

print("Datasets:")

for dataset_name in list(ws.datasets.keys()):

dataset = Dataset.get_by_name(ws, dataset_name)

print("\t", dataset.name, 'version', dataset.version)

Grab a specific version

dataset_v1 = Dataset.get_by_name(ws, 'diabetes dataset', version = 1)

Train a model from a tabular dataset

import os

# Create a folder for the experiment files

experiment_folder = 'diabetes_training_from_tab_dataset'

os.makedirs(experiment_folder, exist_ok=True)

print(experiment_folder, 'folder created')

%%writefile $experiment_folder/diabetes_training.py

# Import libraries

import os

import argparse

from azureml.core import Run, Dataset

import pandas as pd

import numpy as np

import joblib

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

# Get the script arguments (regularization rate and training dataset ID)

parser = argparse.ArgumentParser()

parser.add_argument('--regularization', type=float, dest='reg_rate', default=0.01, help='regularization rate')

parser.add_argument("--input-data", type=str, dest='training_dataset_id', help='training dataset')

args = parser.parse_args()

# Set regularization hyperparameter (passed as an argument to the script)

reg = args.reg_rate

# Get the experiment run context

run = Run.get_context()

# Get the training dataset

print("Loading Data...")

diabetes = run.input_datasets['training_data'].to_pandas_dataframe()

# Separate features and labels

X, y = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].values, diabetes['Diabetic'].values

# Split data into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)

# Train a logistic regression model

print('Training a logistic regression model with regularization rate of', reg)

run.log('Regularization Rate', np.float(reg))

model = LogisticRegression(C=1/reg, solver="liblinear").fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

print('Accuracy:', acc)

run.log('Accuracy', np.float(acc))

# calculate AUC

y_scores = model.predict_proba(X_test)

auc = roc_auc_score(y_test,y_scores[:,1])

print('AUC: ' + str(auc))

run.log('AUC', np.float(auc))

os.makedirs('outputs', exist_ok=True)

# note file saved in the outputs folder is automatically uploaded into experiment record

joblib.dump(value=model, filename='outputs/diabetes_model.pkl')

run.complete()

from azureml.core import Experiment, ScriptRunConfig, Environment

from azureml.core.conda_dependencies import CondaDependencies

from azureml.widgets import RunDetails

# Create a Python environment for the experiment

sklearn_env = Environment("sklearn-env")

# Ensure the required packages are installed (we need scikit-learn, Azure ML defaults, and Azure ML dataprep)

packages = CondaDependencies.create(conda_packages=['scikit-learn','pip'],

pip_packages=['azureml-defaults','azureml-dataprep[pandas]'])

sklearn_env.python.conda_dependencies = packages

# Get the training dataset

diabetes_ds = ws.datasets.get("diabetes dataset")

# Create a script config

script_config = ScriptRunConfig(source_directory=experiment_folder,

script='diabetes_training.py',

arguments = ['--regularization', 0.1, # Regularizaton rate parameter

'--input-data', diabetes_ds.as_named_input('training_data')], # Reference to dataset

environment=sklearn_env)

# submit the experiment

experiment_name = 'mslearn-train-diabetes'

experiment = Experiment(workspace=ws, name=experiment_name)

run = experiment.submit(config=script_config)

RunDetails(run).show()

run.wait_for_completion()

Register the traing model

from azureml.core import Model

run.register_model(model_path='outputs/diabetes_model.pkl', model_name='diabetes_model',

tags={'Training context':'Tabular dataset'}, properties={'AUC': run.get_metrics()['AUC'], 'Accuracy': run.get_metrics()['Accuracy']})

for model in Model.list(ws):

print(model.name, 'version:', model.version)

for tag_name in model.tags:

tag = model.tags[tag_name]

print ('\t',tag_name, ':', tag)

for prop_name in model.properties:

prop = model.properties[prop_name]

print ('\t',prop_name, ':', prop)

print('\n')

Train from a file dataset

import os

# Create a folder for the experiment files

experiment_folder = 'diabetes_training_from_file_dataset'

os.makedirs(experiment_folder, exist_ok=True)

print(experiment_folder, 'folder created')

%%writefile $experiment_folder/diabetes_training.py

# Import libraries

import os

import argparse

from azureml.core import Dataset, Run

import pandas as pd

import numpy as np

import joblib

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

import glob

# Get script arguments (rgularization rate and file dataset mount point)

parser = argparse.ArgumentParser()

parser.add_argument('--regularization', type=float, dest='reg_rate', default=0.01, help='regularization rate')

parser.add_argument('--input-data', type=str, dest='dataset_folder', help='data mount point')

args = parser.parse_args()

# Set regularization hyperparameter (passed as an argument to the script)

reg = args.reg_rate

# Get the experiment run context

run = Run.get_context()

# load the diabetes dataset

print("Loading Data...")

data_path = run.input_datasets['training_files'] # Get the training data path from the input

# (You could also just use args.data_folder if you don't want to rely on a hard-coded friendly name)

# Read the files

all_files = glob.glob(data_path + "/*.csv")

diabetes = pd.concat((pd.read_csv(f) for f in all_files), sort=False)

# Separate features and labels

X, y = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].values, diabetes['Diabetic'].values

# Split data into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)

# Train a logistic regression model

print('Training a logistic regression model with regularization rate of', reg)

run.log('Regularization Rate', np.float(reg))

model = LogisticRegression(C=1/reg, solver="liblinear").fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

print('Accuracy:', acc)

run.log('Accuracy', np.float(acc))

# calculate AUC

y_scores = model.predict_proba(X_test)

auc = roc_auc_score(y_test,y_scores[:,1])

print('AUC: ' + str(auc))

run.log('AUC', np.float(auc))

os.makedirs('outputs', exist_ok=True)

# note file saved in the outputs folder is automatically uploaded into experiment record

joblib.dump(value=model, filename='outputs/diabetes_model.pkl')

run.complete()

from azureml.core import Experiment

from azureml.widgets import RunDetails

# Get the training dataset

diabetes_ds = ws.datasets.get("diabetes file dataset")

# Create a script config

script_config = ScriptRunConfig(source_directory=experiment_folder,

script='diabetes_training.py',

arguments = ['--regularization', 0.1, # Regularizaton rate parameter

'--input-data', diabetes_ds.as_named_input('training_files').as_download()], # Reference to dataset location

environment=sklearn_env) # Use the environment created previously

# submit the experiment

experiment_name = 'mslearn-train-diabetes'

experiment = Experiment(workspace=ws, name=experiment_name)

run = experiment.submit(config=script_config)

RunDetails(run).show()

run.wait_for_completion()

Register the model

from azureml.core import Model

run.register_model(model_path='outputs/diabetes_model.pkl', model_name='diabetes_model',

tags={'Training context':'File dataset'}, properties={'AUC': run.get_metrics()['AUC'], 'Accuracy': run.get_metrics()['Accuracy']})

for model in Model.list(ws):

print(model.name, 'version:', model.version)

for tag_name in model.tags:

tag = model.tags[tag_name]

print ('\t',tag_name, ':', tag)

for prop_name in model.properties:

prop = model.properties[prop_name]

print ('\t',prop_name, ':', prop)

print('\n')

https://microsoftlearning.github.io/mslearn-dp100/instructions/01-create-a-workspace.htmlWork with Compute in Azure Machine Learning

Creating environment files

Create an environment from a specification file

e.g conda

name: py_env

dependencies:

- numpy

- pandas

- scikit-learn

- pip:

- azureml-defaults

then do

from azureml.core import Environment

env = Environment.from_conda_specification(name='training_environment',

file_path='./conda.yml')

can create from existing conda

from azureml.core import Environment

env = Environment.from_existing_conda_environment(name='training_environment',

conda_environment_name='py_env')

create from specifying packages

from azureml.core import Environment

from azureml.core.conda_dependencies import CondaDependencies

env = Environment('training_environment')

deps = CondaDependencies.create(conda_packages=['scikit-learn','pandas','numpy'],

pip_packages=['azureml-defaults'])

env.python.conda_dependencies = deps

Create in containers

env.docker.enabled = True

deps = CondaDependencies.create(conda_packages=['scikit-learn','pandas','pip'],

pip_packages=['azureml-defaults']

env.python.conda_dependencies = deps

Can add you own image

env.docker.base_image='my-base-image'

env.docker.base_image_registry='myregistry.azurecr.io/myimage'

or

env.docker.base_image = None

env.docker.base_dockerfile = './Dockerfile'

you can override the version of package or env

env.python.user_managed_dependencies=True

env.python.interpreter_path = '/opt/miniconda/bin/python'

Register your env

env.register(workspace=ws)

See registered envs

from azureml.core import Environment

env_names = Environment.list(workspace=ws)

for env_name in env_names:

print('Name:',env_name)

Get env and set training script

from azureml.core import Environment

from azureml.train.estimator import Estimator

training_env = Environment.get(workspace=ws, name='training_environment')

estimator = Estimator(source_directory='experiment_folder'

entry_script='training_script.py',

compute_target='local',

environment_definition=training_env)

Create compute targets

from azureml.core import Workspace

from azureml.core.compute import ComputeTarget, AmlCompute

# Load the workspace from the saved config file

ws = Workspace.from_config()

# Specify a name for the compute (unique within the workspace)

compute_name = 'aml-cluster'

# Define compute configuration

compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS11_V2',

min_nodes=0, max_nodes=4,

vm_priority='dedicated' # lowpriority

# Create the compute

aml_cluster = ComputeTarget.create(ws, compute_name, compute_config)

aml_cluster.wait_for_completion(show_output=True)

https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.compute.amlcompute.amlcompute?view=azure-ml-py

An unmanaged compute target is one that is defined and managed outside of the Azure Machine Learning workspace; for example, an Azure virtual machine or an Azure Databricks cluster.

Use the ComputeTarget.attach() method to attach the existing compute based on its target-specific configuration settings.

e.g. connect to a databricks clusters

from azureml.core import Workspace

from azureml.core.compute import ComputeTarget, DatabricksCompute

# Load the workspace from the saved config file

ws = Workspace.from_config()

# Specify a name for the compute (unique within the workspace)

compute_name = 'db_cluster'

# Define configuration for existing Azure Databricks cluster

db_workspace_name = 'db_workspace'

db_resource_group = 'db_resource_group'

db_access_token = '1234-abc-5678-defg-90...'

db_config = DatabricksCompute.attach_configuration(resource_group=db_resource_group,

workspace_name=db_workspace_name,

access_token=db_access_token)

# Create the compute

databricks_compute = ComputeTarget.attach(ws, compute_name, db_config)

databricks_compute.wait_for_completion(True)

If doesn't exist create.

from azureml.core.compute import ComputeTarget, AmlCompute

from azureml.core.compute_target import ComputeTargetException

compute_name = "aml-cluster"

# Check if the compute target exists

try:

aml_cluster = ComputeTarget(workspace=ws, name=compute_name)

print('Found existing cluster.')

except ComputeTargetException:

# If not, create it

compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS11_V2',

max_nodes=4)

aml_cluster = ComputeTarget.create(ws, compute_name, compute_config)

aml_cluster.wait_for_completion(show_output=True)

https://docs.microsoft.com/en-us/azure/machine-learning/how-to-set-up-training-targets

Use compute targets

To use a particular compute target, you can specify it in the appropriate parameter for an experiment run configuration or estimator

from azureml.core import Environment, ScriptRunConfig

compute_name = 'aml-cluster'

training_env = Environment.get(workspace=ws, name='training_environment')

script_config = ScriptRunConfig(source_directory='my_dir',

script='script.py',

environment=env,

compute_target=compute_name)

Instead of specifying the name of the compute target, you can specify a ComputeTarget object, like this:

from azureml.core import Environment, ScriptRunConfig

from azureml.core.compute import ComputeTarget

compute_name = "aml-cluster"

training_cluster = ComputeTarget(workspace=ws, name=compute_name)

training_env = Environment.get(workspace=ws, name='training_environment')

script_config = ScriptRunConfig(source_directory='my_dir',

script='script.py',

environment=env,

compute_target=training_cluster)

Work with Compute Contexts

https://microsoftlearning.github.io/mslearn-dp100/instructions/01-create-a-workspace.html

Orchestrate Machine Learning Pipelines

https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps?view=azure-ml-py

Two scripts

from azureml.pipeline.steps import PythonScriptStep

# Step to run a Python script

step1 = PythonScriptStep(name = 'prepare data',

source_directory = 'scripts',

script_name = 'data_prep.py',

compute_target = 'aml-cluster')

# Step to train a model

step2 = PythonScriptStep(name = 'train model',

source_directory = 'scripts',

script_name = 'train_model.py',

compute_target = 'aml-cluster')

from azureml.pipeline.core import Pipeline

from azureml.core import Experiment

# Construct the pipeline

train_pipeline = Pipeline(workspace = ws, steps = [step1,step2])

# Create an experiment and run the pipeline

experiment = Experiment(workspace = ws, name = 'training-pipeline')

pipeline_run = experiment.submit(train_pipeline)

PipelineData passes data between steps

from azureml.pipeline.core import PipelineData

from azureml.pipeline.steps import PythonScriptStep, EstimatorStep

# Get a dataset for the initial data

raw_ds = Dataset.get_by_name(ws, 'raw_dataset')

# Define a PipelineData object to pass data between steps

data_store = ws.get_default_datastore()

prepped_data = PipelineData('prepped', datastore=data_store)

# Step to run a Python script

step1 = PythonScriptStep(name = 'prepare data',

source_directory = 'scripts',

script_name = 'data_prep.py',

compute_target = 'aml-cluster',

# Script arguments include PipelineData

arguments = ['--raw-ds', raw_ds.as_named_input('raw_data'),

'--out_folder', prepped_data],

# Specify PipelineData as output

outputs=[prepped_data])

# Step to run an estimator

step2 = PythonScriptStep(name = 'train model',

source_directory = 'scripts',

script_name = 'data_prep.py',

compute_target = 'aml-cluster',

# Pass as script argument

arguments=['--in_folder', prepped_data],

# Specify PipelineData as input

inputs=[prepped_data])

# code in data_prep.py

from azureml.core import Run

import argparse

import os

# Get the experiment run context

run = Run.get_context()

# Get arguments

parser = argparse.ArgumentParser()

parser.add_argument('--raw-ds', type=str, dest='raw_dataset_id')

parser.add_argument('--out_folder', type=str, dest='folder')

args = parser.parse_args()

output_folder = args.folder

# Get input dataset as dataframe

raw_df = run.input_datasets['raw_data'].to_pandas_dataframe()

# code to prep data (in this case, just select specific columns)

prepped_df = raw_df[['col1', 'col2', 'col3']]

# Save prepped data to the PipelineData location

os.makedirs(output_folder, exist_ok=True)

output_path = os.path.join(output_folder, 'prepped_data.csv')

prepped_df.to_csv(output_path)

Allow caching with allow_resuse parameter

step1 = PythonScriptStep(name = 'prepare data',

source_directory = 'scripts',

script_name = 'data_prep.py',

compute_target = 'aml-cluster',

runconfig = run_config,

inputs=[raw_ds.as_named_input('raw_data')],

outputs=[prepped_data],

arguments = ['--folder', prepped_data]),

# Disable step reuse

allow_reuse = False)

Force all to run

pipeline_run = experiment.submit(train_pipeline, regenerate_outputs=True)

Publish pipeline

published_pipeline = pipeline.publish(name='training_pipeline',

description='Model training pipeline',

version='1.0')

or call publish method on a successful run

# Get the most recent run of the pipeline

pipeline_experiment = ws.experiments.get('training-pipeline')

run = list(pipeline_experiment.get_runs())[0]

# Publish the pipeline from the run

published_pipeline = run.publish_pipeline(name='training_pipeline',

description='Model training pipeline',

version='1.0')

See URI

rest_endpoint = published_pipeline.endpoint

print(rest_endpoint)

Display runid

import requests

response = requests.post(rest_endpoint,

headers=auth_header,

json={"ExperimentName": "run_training_pipeline"})

run_id = response.json()["Id"]

print(run_id)

Define parameters in a pipeline

from azureml.pipeline.core.graph import PipelineParameter

reg_param = PipelineParameter(name='reg_rate', default_value=0.01)

...

step2 = PythonScriptStep(name = 'train model',

source_directory = 'scripts',

script_name = 'data_prep.py',

compute_target = 'aml-cluster',

# Pass parameter as script argument

arguments=['--in_folder', prepped_data,

'--reg', reg_param],

inputs=[prepped_data])

After publishing you can run a pipeline with a parameter

response = requests.post(rest_endpoint,

headers=auth_header,

json={"ExperimentName": "run_training_pipeline",

"ParameterAssignments": {"reg_rate": 0.1}})

Run the pipeline daily

from azureml.pipeline.core import ScheduleRecurrence, Schedule

daily = ScheduleRecurrence(frequency='Day', interval=1)

pipeline_schedule = Schedule.create(ws, name='Daily Training',

description='trains model every day',

pipeline_id=published_pipeline.id,

experiment_name='Training_Pipeline',

recurrence=daily)

Trigger on data changes

from azureml.core import Datastore

from azureml.pipeline.core import Schedule

training_datastore = Datastore(workspace=ws, name='blob_data')

pipeline_schedule = Schedule.create(ws, name='Reactive Training',

description='trains model on data change',

pipeline_id=published_pipeline_id,

experiment_name='Training_Pipeline',

datastore=training_datastore,

path_on_datastore='data/training')

Exercise: Create a pipeline

https://microsoftlearning.github.io/mslearn-dp100/instructions/08-create-a-pipeline.html

https://github.com/MicrosoftLearning/mslearn-dp100/blob/main/08%20-%20Create%20a%20Pipeline.ipynb

!pip install --upgrade azureml-sdk azureml-widgets

import azureml.core

from azureml.core import Workspace

# Load the workspace from the saved config file

ws = Workspace.from_config()

print('Ready to use Azure ML {} to work with {}'.format(azureml.core.VERSION, ws.name))

Prepare data

from azureml.core import Dataset

default_ds = ws.get_default_datastore()

if 'diabetes dataset' not in ws.datasets:

default_ds.upload_files(files=['./data/diabetes.csv', './data/diabetes2.csv'], # Upload the diabetes csv files in /data

target_path='diabetes-data/', # Put it in a folder path in the datastore

overwrite=True, # Replace existing files of the same name

show_progress=True)

#Create a tabular dataset from the path on the datastore (this may take a short while)

tab_data_set = Dataset.Tabular.from_delimited_files(path=(default_ds, 'diabetes-data/*.csv'))

# Register the tabular dataset

try:

tab_data_set = tab_data_set.register(workspace=ws,

name='diabetes dataset',

description='diabetes data',

tags = {'format':'CSV'},

create_new_version=True)

print('Dataset registered.')

except Exception as ex:

print(ex)

else:

print('Dataset already registered.')

Create folder

import os

# Create a folder for the pipeline step files

experiment_folder = 'diabetes_pipeline'

os.makedirs(experiment_folder, exist_ok=True)

print(experiment_folder)

create the first script, which will read data from the diabetes dataset and apply some simple pre-processing to remove any rows with missing data and normalize the numeric features so they're on a similar scale.

The script includes a argument named --prepped-data, which references the folder where the resulting data should be saved.

%%writefile $experiment_folder/prep_diabetes.py

# Import libraries

import os

import argparse

import pandas as pd

from azureml.core import Run

from sklearn.preprocessing import MinMaxScaler

# Get parameters

parser = argparse.ArgumentParser()

parser.add_argument("--input-data", type=str, dest='raw_dataset_id', help='raw dataset')

parser.add_argument('--prepped-data', type=str, dest='prepped_data', default='prepped_data', help='Folder for results')

args = parser.parse_args()

save_folder = args.prepped_data

# Get the experiment run context

run = Run.get_context()

# load the data (passed as an input dataset)

print("Loading Data...")

diabetes = run.input_datasets['raw_data'].to_pandas_dataframe()

# Log raw row count

row_count = (len(diabetes))

run.log('raw_rows', row_count)

# remove nulls

diabetes = diabetes.dropna()

# Normalize the numeric columns

scaler = MinMaxScaler()

num_cols = ['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree']

diabetes[num_cols] = scaler.fit_transform(diabetes[num_cols])

# Log processed rows

row_count = (len(diabetes))

run.log('processed_rows', row_count)

# Save the prepped data

print("Saving Data...")

os.makedirs(save_folder, exist_ok=True)

save_path = os.path.join(save_folder,'data.csv')

diabetes.to_csv(save_path, index=False, header=True)

# End the run

run.complete()

create the script for the second step, which will train a model. The script includes a argument named --training-folder, which references the folder where the prepared data was saved by the previous step

%%writefile $experiment_folder/train_diabetes.py

# Import libraries

from azureml.core import Run, Model

import argparse

import pandas as pd

import numpy as np

import joblib

import os

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

import matplotlib.pyplot as plt

# Get parameters

parser = argparse.ArgumentParser()

parser.add_argument("--training-folder", type=str, dest='training_folder', help='training data folder')

args = parser.parse_args()

training_folder = args.training_folder

# Get the experiment run context

run = Run.get_context()

# load the prepared data file in the training folder

print("Loading Data...")

file_path = os.path.join(training_folder,'data.csv')

diabetes = pd.read_csv(file_path)

# Separate features and labels

X, y = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].values, diabetes['Diabetic'].values

# Split data into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)

# Train adecision tree model

print('Training a decision tree model...')

model = DecisionTreeClassifier().fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

print('Accuracy:', acc)

run.log('Accuracy', np.float(acc))

# calculate AUC

y_scores = model.predict_proba(X_test)

auc = roc_auc_score(y_test,y_scores[:,1])

print('AUC: ' + str(auc))

run.log('AUC', np.float(auc))

# plot ROC curve

fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])

fig = plt.figure(figsize=(6, 4))

# Plot the diagonal 50% line

plt.plot([0, 1], [0, 1], 'k--')

# Plot the FPR and TPR achieved by our model

plt.plot(fpr, tpr)

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('ROC Curve')

run.log_image(name = "ROC", plot = fig)

plt.show()

# Save the trained model in the outputs folder

print("Saving model...")

os.makedirs('outputs', exist_ok=True)

model_file = os.path.join('outputs', 'diabetes_model.pkl')

joblib.dump(value=model, filename=model_file)

# Register the model

print('Registering model...')

Model.register(workspace=run.experiment.workspace,

model_path = model_file,

model_name = 'diabetes_model',

tags={'Training context':'Pipeline'},

properties={'AUC': np.float(auc), 'Accuracy': np.float(acc)})

run.complete()

Use the same compute for both steps

from azureml.core.compute import ComputeTarget, AmlCompute

from azureml.core.compute_target import ComputeTargetException

cluster_name = "compute-ray"

try:

# Check for existing compute target

pipeline_cluster = ComputeTarget(workspace=ws, name=cluster_name)

print('Found existing cluster, use it.')

except ComputeTargetException:

# If it doesn't already exist, create it

try:

compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS11_V2', max_nodes=2)

pipeline_cluster = ComputeTarget.create(ws, cluster_name, compute_config)

pipeline_cluster.wait_for_completion(show_output=True)

except Exception as ex:

print(ex)

Create env

from azureml.core import Environment

from azureml.core.conda_dependencies import CondaDependencies

from azureml.core.runconfig import RunConfiguration

# Create a Python environment for the experiment

diabetes_env = Environment("diabetes-pipeline-env")

diabetes_env.python.user_managed_dependencies = False # Let Azure ML manage dependencies

diabetes_env.docker.enabled = True # Use a docker container

# Create a set of package dependencies

diabetes_packages = CondaDependencies.create(conda_packages=['scikit-learn','ipykernel','matplotlib','pandas','pip'],

pip_packages=['azureml-defaults','azureml-dataprep[pandas]','pyarrow'])

# Add the dependencies to the environment

diabetes_env.python.conda_dependencies = diabetes_packages

# Register the environment

diabetes_env.register(workspace=ws)

registered_env = Environment.get(ws, 'diabetes-pipeline-env')

# Create a new runconfig object for the pipeline

pipeline_run_config = RunConfiguration()

# Use the compute you created above.

pipeline_run_config.target = pipeline_cluster

# Assign the environment to the run configuration

pipeline_run_config.environment = registered_env

print ("Run configuration created.")

Create and run pipeline

from azureml.pipeline.core import PipelineData

from azureml.pipeline.steps import PythonScriptStep

# Get the training dataset

diabetes_ds = ws.datasets.get("diabetes dataset")

# Create a PipelineData (temporary Data Reference) for the model folder

prepped_data_folder = PipelineData("prepped_data_folder", datastore=ws.get_default_datastore())

# Step 1, Run the data prep script

train_step = PythonScriptStep(name = "Prepare Data",

source_directory = experiment_folder,

script_name = "prep_diabetes.py",

arguments = ['--input-data', diabetes_ds.as_named_input('raw_data'),

'--prepped-data', prepped_data_folder],

outputs=[prepped_data_folder],

compute_target = pipeline_cluster,

runconfig = pipeline_run_config,

allow_reuse = True)

# Step 2, run the training script

register_step = PythonScriptStep(name = "Train and Register Model",

source_directory = experiment_folder,

script_name = "train_diabetes.py",

arguments = ['--training-folder', prepped_data_folder],

inputs=[prepped_data_folder],

compute_target = pipeline_cluster,

runconfig = pipeline_run_config,

allow_reuse = True)

print("Pipeline steps defined")

Build the pipeline and run as an experiment

from azureml.core import Experiment

from azureml.pipeline.core import Pipeline

from azureml.widgets import RunDetails

# Construct the pipeline

pipeline_steps = [train_step, register_step]

pipeline = Pipeline(workspace=ws, steps=pipeline_steps)

print("Pipeline is built.")

# Create an experiment and run the pipeline

experiment = Experiment(workspace=ws, name = 'mslearn-diabetes-pipeline')

pipeline_run = experiment.submit(pipeline, regenerate_outputs=True)

print("Pipeline submitted for execution.")

RunDetails(pipeline_run).show()

pipeline_run.wait_for_completion(show_output=True)

Monitor the run in the Experiments tab

When the pipeline has finished, you can examine the metrics recorded by it's child runs.

for run in pipeline_run.get_children():

print(run.name, ':')

metrics = run.get_metrics()

for metric_name in metrics:

print('\t',metric_name, ":", metrics[metric_name])

a new model should be registered with a Training context tag indicating it was trained in a pipeline. See it as

from azureml.core import Model

for model in Model.list(ws):

print(model.name, 'version:', model.version)

for tag_name in model.tags:

tag = model.tags[tag_name]

print ('\t',tag_name, ':', tag)

for prop_name in model.properties:

prop = model.properties[prop_name]

print ('\t',prop_name, ':', prop)

print('\n')

Publish the pipeline

# Publish the pipeline from the run

published_pipeline = pipeline_run.publish_pipeline(

name="diabetes-training-pipeline", description="Trains diabetes model", version="1.0")

published_pipeline

See the endpoint

rest_endpoint = published_pipeline.endpoint

print(rest_endpoint)

Call the pipeline endpoint

use the authorization header from your current connection to your Azure workspace

from azureml.core.authentication import InteractiveLoginAuthentication

interactive_auth = InteractiveLoginAuthentication()

auth_header = interactive_auth.get_authentication_header()

print("Authentication header ready.")

Call the rest interface

import requests

experiment_name = 'mslearn-diabetes-pipeline'

rest_endpoint = published_pipeline.endpoint

response = requests.post(rest_endpoint,

headers=auth_header,

json={"ExperimentName": experiment_name})

run_id = response.json()["Id"]

run_id

Wait for the run to complete

from azureml.pipeline.core.run import PipelineRun

published_pipeline_run = PipelineRun(ws.experiments[experiment_name], run_id)

pipeline_run.wait_for_completion(show_output=True)

Schedule the pipeline to run week and retain with new data

from azureml.pipeline.core import ScheduleRecurrence, Schedule

# Submit the Pipeline every Monday at 00:00 UTC

recurrence = ScheduleRecurrence(frequency="Week", interval=1, week_days=["Monday"], time_of_day="00:00")

weekly_schedule = Schedule.create(ws, name="weekly-diabetes-training",

description="Based on time",

pipeline_id=published_pipeline.id,

experiment_name='mslearn-diabetes-pipeline',

recurrence=recurrence)

print('Pipeline scheduled.')

Retrieve schedules as

schedules = Schedule.list(ws)

schedules

Check the latest run

pipeline_experiment = ws.experiments.get('mslearn-diabetes-pipeline')

latest_run = list(pipeline_experiment.get_runs())[0]

latest_run.get_details()

Deploy real-time machine learning services with Azure Machine Learning

Register a trained model

from azureml.core import Model

classification_model = Model.register(workspace=ws,

model_name='classification_model',

model_path='model.pkl', # local path

description='A classification model')

You can also register from a run

run.register_model( model_name='classification_model',

model_path='outputs/model.pkl', # run outputs path

description='A classification model')

Create an entry script (or scoring script)

import json

import joblib

import numpy as np

from azureml.core.model import Model

# Called when the service is loaded

def init():

global model

# Get the path to the registered model file and load it

model_path = Model.get_model_path('classification_model')

model = joblib.load(model_path)

# Called when a request is received

def run(raw_data):

# Get the input data as a numpy array

data = np.array(json.loads(raw_data)['data'])

# Get a prediction from the model

predictions = model.predict(data)

# Return the predictions as any JSON serializable format

return predictions.tolist()

Create an environment

from azureml.core.conda_dependencies import CondaDependencies

# Add the dependencies for your model

myenv = CondaDependencies()

myenv.add_conda_package("scikit-learn")

# Save the environment config as a .yml file

env_file = 'service_files/env.yml'

with open(env_file,"w") as f:

f.write(myenv.serialize_to_string())

print("Saved dependency info in", env_file)

Create env and entry script

from azureml.core.model import InferenceConfig

classifier_inference_config = InferenceConfig(runtime= "python",

source_directory = 'service_files',

entry_script="score.py",

conda_file="env.yml")

Create AKS cluster for deployment

from azureml.core.compute import ComputeTarget, AksCompute

cluster_name = 'aks-cluster'

compute_config = AksCompute.provisioning_configuration(location='eastus')

production_cluster = ComputeTarget.create(ws, cluster_name, compute_config)

production_cluster.wait_for_completion(show_output=True)

Set compute

from azureml.core.webservice import AksWebservice

classifier_deploy_config = AksWebservice.deploy_configuration(cpu_cores = 1,

memory_gb = 1)

Deploy the model

from azureml.core.model import Model

model = ws.models['classification_model']

service = Model.deploy(workspace=ws,

name = 'classifier-service',

models = [model],

inference_config = classifier_inference_config,

deployment_config = classifier_deploy_config,

deployment_target = production_cluster)

service.wait_for_deployment(show_output = True)

Get prdictions (response)

import json

# An array of new data cases

x_new = [[0.1,2.3,4.1,2.0],

[0.2,1.8,3.9,2.1]]

# Convert the array to a serializable list in a JSON document

json_data = json.dumps({"data": x_new})

# Call the web service, passing the input data

response = service.run(input_data = json_data)

# Get the predictions

predictions = json.loads(response)

# Print the predicted class for each case.

for i in range(len(x_new)):

print (x_new[i]), predictions[i] )

If using a REST api (not SDK)

endpoint = service.scoring_uri

print(endpoint)

import requests

import json

# An array of new data cases

x_new = [[0.1,2.3,4.1,2.0],

[0.2,1.8,3.9,2.1]]

# Convert the array to a serializable list in a JSON document

json_data = json.dumps({"data": x_new})

# Set the content type in the request headers

request_headers = { 'Content-Type':'application/json' }

# Call the service

response = requests.post(url = endpoint,

data = json_data,

headers = request_headers)

# Get the predictions from the JSON response

predictions = json.loads(response.json())

# Print the predicted class for each case.

for i in range(len(x_new)):

print (x_new[i]), predictions[i] )

Can authenticate with keys

primary_key, secondary_key = service.get_keys()

You can get you token as

import requests

import json

# An array of new data cases

x_new = [[0.1,2.3,4.1,2.0],

[0.2,1.8,3.9,2.1]]

# Convert the array to a serializable list in a JSON document

json_data = json.dumps({"data": x_new})

# Set the content type in the request headers

request_headers = { "Content-Type":"application/json",

"Authorization":"Bearer " + key_or_token }

# Call the service

response = requests.post(url = endpoint,

data = json_data,

headers = request_headers)

# Get the predictions from the JSON response

predictions = json.loads(response.json())

# Print the predicted class for each case.

for i in range(len(x_new)):

print (x_new[i]), predictions[i] )

Check the server state

from azureml.core.webservice import AksWebservice

# Get the deployed service

service = AksWebservice(name='classifier-service', workspace=ws)

# Check its state

print(service.state)

See service logs

print(service.get_logs())

Deploy to local container

from azureml.core.webservice import LocalWebservice

deployment_config = LocalWebservice.deploy_configuration(port=8890)

service = Model.deploy(ws, 'test-svc', [model], inference_config, deployment_config)

Test the deployed service using the SDK

print(service.run(input_data = json_data))

troubleshoot runtime issues by making changes to the scoring file that is referenced in the inference configuration, and reloading the service without redeploying it (s

service.reload()

print(service.run(input_data = json_data))

Exercise

https://github.com/MicrosoftLearning/mslearn-dp100/blob/main/09%20-%20Create%20a%20Real-time%20Inferencing%20Service.ipynb

!pip install --upgrade azureml-sdk azureml-widgets

Connect to workspace

import azureml.core

from azureml.core import Workspace

# Load the workspace from the saved config file

ws = Workspace.from_config()

print('Ready to use Azure ML {} to work with {}'.format(azureml.core.VERSION, ws.name))

Train and register a model

from azureml.core import Experiment

from azureml.core import Model

import pandas as pd

import numpy as np

import joblib

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

# Create an Azure ML experiment in your workspace

experiment = Experiment(workspace=ws, name="mslearn-train-diabetes")

run = experiment.start_logging()

print("Starting experiment:", experiment.name)

# load the diabetes dataset

print("Loading Data...")

diabetes = pd.read_csv('data/diabetes.csv')

# Separate features and labels

X, y = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].values, diabetes['Diabetic'].values

# Split data into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)

# Train a decision tree model

print('Training a decision tree model')

model = DecisionTreeClassifier().fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

print('Accuracy:', acc)

run.log('Accuracy', np.float(acc))

# calculate AUC

y_scores = model.predict_proba(X_test)

auc = roc_auc_score(y_test,y_scores[:,1])

print('AUC: ' + str(auc))

run.log('AUC', np.float(auc))

# Save the trained model

model_file = 'diabetes_model.pkl'

joblib.dump(value=model, filename=model_file)

run.upload_file(name = 'outputs/' + model_file, path_or_stream = './' + model_file)

# Complete the run

run.complete()

# Register the model

run.register_model(model_path='outputs/diabetes_model.pkl', model_name='diabetes_model',

tags={'Training context':'Inline Training'},

properties={'AUC': run.get_metrics()['AUC'], 'Accuracy': run.get_metrics()['Accuracy']})

print('Model trained and registered.')

Deploy the model as a web service

from azureml.core import Model

for model in Model.list(ws):

print(model.name, 'version:', model.version)

for tag_name in model.tags:

tag = model.tags[tag_name]

print ('\t',tag_name, ':', tag)

for prop_name in model.properties:

prop = model.properties[prop_name]

print ('\t',prop_name, ':', prop)

print('\n')

Get the model to deploy

model = ws.models['diabetes_model']

print(model.name, 'version', model.version)

Set folder to host web service

import os

folder_name = 'diabetes_service'

# Create a folder for the web service files

experiment_folder = './' + folder_name

os.makedirs(experiment_folder, exist_ok=True)

print(folder_name, 'folder created.')

# Set path for scoring script

script_file = os.path.join(experiment_folder,"score_diabetes.py")

Create an entry script

import json

import joblib

import numpy as np

from azureml.core.model import Model

# Called when the service is loaded

def init():

global model

# Get the path to the deployed model file and load it

model_path = Model.get_model_path('diabetes_model')

model = joblib.load(model_path)

# Called when a request is received

def run(raw_data):

# Get the input data as a numpy array

data = np.array(json.loads(raw_data)['data'])

# Get a prediction from the model

predictions = model.predict(data)

# Get the corresponding classname for each prediction (0 or 1)

classnames = ['not-diabetic', 'diabetic']

predicted_classes = []

for prediction in predictions:

predicted_classes.append(classnames[prediction])

# Return the predictions as JSON

return json.dumps(predicted_classes)

Create env

from azureml.core.conda_dependencies import CondaDependencies

# Add the dependencies for our model (AzureML defaults is already included)

myenv = CondaDependencies()

myenv.add_conda_package('scikit-learn')

# Save the environment config as a .yml file

env_file = os.path.join(experiment_folder,"diabetes_env.yml")

with open(env_file,"w") as f:

f.write(myenv.serialize_to_string())

print("Saved dependency info in", env_file)

# Print the .yml file

with open(env_file,"r") as f:

print(f.read())

deploy the container a service named diabetes-service

1. Define an inference configuration, which includes the scoring and environment files required to load and use the model.

2. Define a deployment configuration that defines the execution environment in which the service will be hosted. In this case, an Azure Container Instance.

3. Deploy the model as a web service.

4. Verify the status of the deployed service.

from azureml.core.webservice import AciWebservice

from azureml.core.model import InferenceConfig

# Configure the scoring environment

inference_config = InferenceConfig(runtime= "python",

entry_script=script_file,

conda_file=env_file)

deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

service_name = "diabetes-service"

service = Model.deploy(ws, service_name, [model], inference_config, deployment_config)

service.wait_for_deployment(True)

print(service.state)

See the logs

print(service.get_logs())

# If you need to make a change and redeploy, you may need to delete unhealthy service using the following code:

#service.delete()

See Endpoints

for webservice_name in ws.webservices:

print(webservice_name)

consumer the service

import json

x_new = [[2,180,74,24,21,23.9091702,1.488172308,22]]

print ('Patient: {}'.format(x_new[0]))

# Convert the array to a serializable list in a JSON document

input_json = json.dumps({"data": x_new})

# Call the web service, passing the input data (the web service will also accept the data in binary format)

predictions = service.run(input_data = input_json)

# Get the predicted class - it'll be the first (and only) one.

predicted_classes = json.loads(predictions)

print(predicted_classes[0])

Send multiple entries

import json

# This time our input is an array of two feature arrays

x_new = [[2,180,74,24,21,23.9091702,1.488172308,22],

[0,148,58,11,179,39.19207553,0.160829008,45]]

# Convert the array or arrays to a serializable list in a JSON document

input_json = json.dumps({"data": x_new})

# Call the web service, passing the input data

predictions = service.run(input_data = input_json)

# Get the predicted classes.

predicted_classes = json.loads(predictions)

for i in range(len(x_new)):

print ("Patient {}".format(x_new[i]), predicted_classes[i] )

See endpoint

endpoint = service.scoring_uri

print(endpoint)

Make HTTP request

import requests

import json

x_new = [[2,180,74,24,21,23.9091702,1.488172308,22],

[0,148,58,11,179,39.19207553,0.160829008,45]]

# Convert the array to a serializable list in a JSON document

input_json = json.dumps({"data": x_new})

# Set the content type

headers = { 'Content-Type':'application/json' }

predictions = requests.post(endpoint, input_json, headers = headers)

predicted_classes = json.loads(predictions.json())

for i in range(len(x_new)):

print ("Patient {}".format(x_new[i]), predicted_classes[i] )

Delete the service

service.delete()

print ('Service deleted.')

More info in docs https://docs.microsoft.com/en-us/azure/machine-learning/how-to-deploy-and-where?tabs=azcli

Deploy batch inference pipelines with Azure Machine Learning

Register a model

from azureml.core import Model

classification_model = Model.register(workspace=your_workspace,

model_name='classification_model',

model_path='model.pkl', # local path

description='A classification model')

or

run.register_model( model_name='classification_model',

model_path='outputs/model.pkl', # run outputs path

description='A classification model')

Create a scoring script. init called when the pipeline is initiated. run(mini-batch) for each of batch of data to be processed

import os

import numpy as np

from azureml.core import Model

import joblib

def init():

# Runs when the pipeline step is initialized

global model

# load the model

model_path = Model.get_model_path('classification_model')

model = joblib.load(model_path)

def run(mini_batch):

# This runs for each batch

resultList = []

# process each file in the batch

for f in mini_batch:

# Read comma-delimited data into an array

data = np.genfromtxt(f, delimiter=',')

# Reshape into a 2-dimensional array for model input

prediction = model.predict(data.reshape(1, -1))

# Append prediction to results

resultList.append("{}: {}".format(os.path.basename(f), prediction[0]))

return resultList

Create a pipeline with a parallel run-step

from azureml.pipeline.steps import ParallelRunConfig, ParallelRunStep

from azureml.pipeline.core import PipelineData

from azureml.pipeline.core import Pipeline

# Get the batch dataset for input

batch_data_set = ws.datasets['batch-data']

# Set the output location

default_ds = ws.get_default_datastore()

output_dir = PipelineData(name='inferences',

datastore=default_ds,

output_path_on_compute='results')

# Define the parallel run step step configuration

parallel_run_config = ParallelRunConfig(

source_directory='batch_scripts',

entry_script="batch_scoring_script.py",

mini_batch_size="5",

error_threshold=10,

output_action="append_row",

environment=batch_env,

compute_target=aml_cluster,

node_count=4)

# Create the parallel run step

parallelrun_step = ParallelRunStep(

name='batch-score',

parallel_run_config=parallel_run_config,

inputs=[batch_data_set.as_named_input('batch_data')],

output=output_dir,

arguments=[],

allow_reuse=True

)

# Create the pipeline

pipeline = Pipeline(workspace=ws, steps=[parallelrun_step])

Run the pipeline and retrive the output script

from azureml.core import Experiment

# Run the pipeline as an experiment

pipeline_run = Experiment(ws, 'batch_prediction_pipeline').submit(pipeline)

pipeline_run.wait_for_completion(show_output=True)

# Get the outputs from the first (and only) step

prediction_run = next(pipeline_run.get_children())

prediction_output = prediction_run.get_output_data('inferences')

prediction_output.download(local_path='results')

# Find the parallel_run_step.txt file

for root, dirs, files in os.walk('results'):

for file in files:

if file.endswith('parallel_run_step.txt'):

result_file = os.path.join(root,file)

# Load and display the results

df = pd.read_csv(result_file, delimiter=":", header=None)

df.columns = ["File", "Prediction"]

print(df)

Publishing

as a REST service

published_pipeline = pipeline_run.publish_pipeline(name='Batch_Prediction_Pipeline',

description='Batch pipeline',

version='1.0')

rest_endpoint = published_pipeline.endpoint

Use the service endpoint

import requests

response = requests.post(rest_endpoint,

headers=auth_header,

json={"ExperimentName": "Batch_Prediction"})

run_id = response.json()["Id"]

Schedule the pipeline

from azureml.pipeline.core import ScheduleRecurrence, Schedule

weekly = ScheduleRecurrence(frequency='Week', interval=1)

pipeline_schedule = Schedule.create(ws, name='Weekly Predictions',

description='batch inferencing',

pipeline_id=published_pipeline.id,

experiment_name='Batch_Prediction',

recurrence=weekly)

Exercise

https://github.com/MicrosoftLearning/mslearn-dp100/blob/main/10%20-%20Create%20a%20Batch%20Inferencing%20Service.ipynb

!pip install --upgrade azureml-sdk azureml-widgets

import azureml.core

from azureml.core import Workspace

# Load the workspace from the saved config file

ws = Workspace.from_config()

print('Ready to use Azure ML {} to work with {}'.format(azureml.core.VERSION, ws.name))

Train and register a model

from azureml.core import Experiment

from azureml.core import Model

import pandas as pd

import numpy as np

import joblib

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

# Create an Azure ML experiment in your workspace

experiment = Experiment(workspace=ws, name='mslearn-train-diabetes')

run = experiment.start_logging()

print("Starting experiment:", experiment.name)

# load the diabetes dataset

print("Loading Data...")

diabetes = pd.read_csv('data/diabetes.csv')

# Separate features and labels

X, y = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].values, diabetes['Diabetic'].values

# Split data into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)

# Train a decision tree model

print('Training a decision tree model')

model = DecisionTreeClassifier().fit(X_train, y_train)

# calculate accuracy

y_hat = model.predict(X_test)

acc = np.average(y_hat == y_test)

print('Accuracy:', acc)

run.log('Accuracy', np.float(acc))

# calculate AUC

y_scores = model.predict_proba(X_test)

auc = roc_auc_score(y_test,y_scores[:,1])

print('AUC: ' + str(auc))

run.log('AUC', np.float(auc))

# Save the trained model

model_file = 'diabetes_model.pkl'

joblib.dump(value=model, filename=model_file)

run.upload_file(name = 'outputs/' + model_file, path_or_stream = './' + model_file)

# Complete the run

run.complete()

# Register the model

run.register_model(model_path='outputs/diabetes_model.pkl', model_name='diabetes_model',

tags={'Training context':'Inline Training'},

properties={'AUC': run.get_metrics()['AUC'], 'Accuracy': run.get_metrics()['Accuracy']})

print('Model trained and registered.')

Generate and upload batch data

from azureml.core import Datastore, Dataset

import pandas as pd

import os

# Set default data store

ws.set_default_datastore('workspaceblobstore')

default_ds = ws.get_default_datastore()

# Enumerate all datastores, indicating which is the default

for ds_name in ws.datastores:

print(ds_name, "- Default =", ds_name == default_ds.name)

# Load the diabetes data

diabetes = pd.read_csv('data/diabetes2.csv')

# Get a 100-item sample of the feature columns (not the diabetic label)

sample = diabetes[['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']].sample(n=100).values

# Create a folder

batch_folder = './batch-data'

os.makedirs(batch_folder, exist_ok=True)

print("Folder created!")

# Save each sample as a separate file

print("Saving files...")

for i in range(100):

fname = str(i+1) + '.csv'

sample[i].tofile(os.path.join(batch_folder, fname), sep=",")

print("files saved!")

# Upload the files to the default datastore

print("Uploading files to datastore...")

default_ds = ws.get_default_datastore()

default_ds.upload(src_dir="batch-data", target_path="batch-data", overwrite=True, show_progress=True)

# Register a dataset for the input data

batch_data_set = Dataset.File.from_files(path=(default_ds, 'batch-data/'), validate=False)

try:

batch_data_set = batch_data_set.register(workspace=ws,

name='batch-data',

description='batch data',

create_new_version=True)

except Exception as ex:

print(ex)

print("Done!")

Create compute

from azureml.core.compute import ComputeTarget, AmlCompute

from azureml.core.compute_target import ComputeTargetException

cluster_name = "your-compute-cluster"

try:

# Check for existing compute target

inference_cluster = ComputeTarget(workspace=ws, name=cluster_name)

print('Found existing cluster, use it.')

except ComputeTargetException:

# If it doesn't already exist, create it

try:

compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS11_V2', max_nodes=2)

inference_cluster = ComputeTarget.create(ws, cluster_name, compute_config)

inference_cluster.wait_for_completion(show_output=True)

except Exception as ex:

print(ex)

Create a pipline for batch inferencing

import os

# Create a folder for the experiment files

experiment_folder = 'batch_pipeline'

os.makedirs(experiment_folder, exist_ok=True)

print(experiment_folder)

write script

%%writefile $experiment_folder/batch_diabetes.py

import os

import numpy as np

from azureml.core import Model

import joblib

def init():

# Runs when the pipeline step is initialized

global model

# load the model

model_path = Model.get_model_path('diabetes_model')

model = joblib.load(model_path)

def run(mini_batch):

# This runs for each batch

resultList = []

# process each file in the batch

for f in mini_batch:

# Read the comma-delimited data into an array

data = np.genfromtxt(f, delimiter=',')

# Reshape into a 2-dimensional array for prediction (model expects multiple items)

prediction = model.predict(data.reshape(1, -1))

# Append prediction to results

resultList.append("{}: {}".format(os.path.basename(f), prediction[0]))

return resultList

Define run context with requirements

from azureml.core import Environment

from azureml.core.runconfig import DEFAULT_CPU_IMAGE

from azureml.core.runconfig import CondaDependencies

# Add dependencies required by the model

# For scikit-learn models, you need scikit-learn

# For parallel pipeline steps, you need azureml-core and azureml-dataprep[fuse]

cd = CondaDependencies.create(conda_packages=['scikit-learn','pip'],

pip_packages=['azureml-defaults','azureml-core','azureml-dataprep[fuse]'])

batch_env = Environment(name='batch_environment')

batch_env.python.conda_dependencies = cd

batch_env.docker.enabled = True

batch_env.docker.base_image = DEFAULT_CPU_IMAGE

print('Configuration ready.')

use a pipeline to run the batch prediction script, generate predictions from the input data, and save the results as a text file in the output folder

from azureml.pipeline.steps import ParallelRunConfig, ParallelRunStep

from azureml.pipeline.core import PipelineData

default_ds = ws.get_default_datastore()

output_dir = PipelineData(name='inferences',

datastore=default_ds,

output_path_on_compute='diabetes/results')

parallel_run_config = ParallelRunConfig(

source_directory=experiment_folder,

entry_script="batch_diabetes.py",

mini_batch_size="5",

error_threshold=10,

output_action="append_row",

environment=batch_env,

compute_target=inference_cluster,

node_count=2)

parallelrun_step = ParallelRunStep(

name='batch-score-diabetes',

parallel_run_config=parallel_run_config,

inputs=[batch_data_set.as_named_input('diabetes_batch')],

output=output_dir,

arguments=[],

allow_reuse=True

)

print('Steps defined')

put the step into a pipeline and run in

from azureml.core import Experiment

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[parallelrun_step])

pipeline_run = Experiment(ws, 'mslearn-diabetes-batch').submit(pipeline)

pipeline_run.wait_for_completion(show_output=True)

Retrieve predictions as

import pandas as pd

import shutil

# Remove the local results folder if left over from a previous run

shutil.rmtree('diabetes-results', ignore_errors=True)

# Get the run for the first step and download its output

prediction_run = next(pipeline_run.get_children())

prediction_output = prediction_run.get_output_data('inferences')

prediction_output.download(local_path='diabetes-results')

# Traverse the folder hierarchy and find the results file

for root, dirs, files in os.walk('diabetes-results'):

for file in files:

if file.endswith('parallel_run_step.txt'):

result_file = os.path.join(root,file)

# cleanup output format

df = pd.read_csv(result_file, delimiter=":", header=None)

df.columns = ["File", "Prediction"]

# Display the first 20 results

df.head(20)

Publish the pipeline and its REST interface

published_pipeline = pipeline_run.publish_pipeline(

name='diabetes-batch-pipeline', description='Batch scoring of diabetes data', version='1.0')

published_pipeline

you can see the end point in the Azure portal or

rest_endpoint = published_pipeline.endpoint

print(rest_endpoint)

make a REST call over HTTP

from azureml.core.authentication import InteractiveLoginAuthentication

interactive_auth = InteractiveLoginAuthentication()

auth_header = interactive_auth.get_authentication_header()

print('Authentication header ready.')

import requests

rest_endpoint = published_pipeline.endpoint

response = requests.post(rest_endpoint,

headers=auth_header,

json={"ExperimentName": "mslearn-diabetes-batch"})

run_id = response.json()["Id"]

run_id

from azureml.pipeline.core.run import PipelineRun

from azureml.widgets import RunDetails

published_pipeline_run = PipelineRun(ws.experiments['mslearn-diabetes-batch'], run_id)

# Block until the run completes

published_pipeline_run.wait_for_completion(show_output=True)