jprdonnelly/MachineLearningNotebooks
1
0
Fork 0
mirror of https://github.com/Azure/MachineLearningNotebooks.git synced 2025-12-19 17:17:04 -05:00
Code Issues Projects Releases Wiki Activity

update samples from Release-102 as a part of SDK release

Browse Source
This commit is contained in:
amlrelsa-ms
2021-06-07 17:34:51 +00:00
parent 8f89d88def
commit a47e50b79a
44 changed files with 610 additions and 798 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
tutorials/compute-instance-quickstarts/quickstart-azureml-in-10mins/quickstart-azureml-in-10mins.ipynb
View File

@@ -23,59 +23,9 @@
"\n",
"You'll learn how to:\n",
"\n",
"> * Download a dataset and look at the data\n",
"> * Train an image classification model and log metrics\n",
"> * Deploy the model"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"## Connect to your workspace and create an experiment\n",
"\n",
"Import some libraries and create an experiment to track the runs in your workspace. A workspace can have multiple experiments, and all users that have access to the workspace can collaborate on them."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612965916889
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"import azureml.core\n",
"from azureml.core import Workspace\n",
"from azureml.core import Experiment\n",
"\n",
"# connect to your workspace\n",
"ws = Workspace.from_config()\n",
"\n",
"# create experiment and start logging to a new run in the experiment\n",
"experiment_name = \"azure-ml-in10-mins-tutorial\"\n",
"exp = Experiment(workspace=ws, name=experiment_name)\n",
"run = exp.start_logging(snapshot_directory=None)"
"* Download a dataset and look at the data\n",
"* Train an image classification model and log metrics using MLflow\n",
"* Deploy the model to do real-time inference"
]
},
{
@@ -95,46 +45,23 @@
"* Download the MNIST dataset\n",
"* Display some sample images\n",
"\n",
"### Download the MNIST dataset\n",
"\n",
"You'll use Azure Open Datasets to get the raw MNIST data files. [Azure Open Datasets](https://docs.microsoft.com/azure/open-datasets/overview-what-are-open-datasets) are curated public datasets that you can use to add scenario-specific features to machine learning solutions for better models. Each dataset has a corresponding class, `MNIST` in this case, to retrieve the data in different ways."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612965922274
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"from azureml.core import Dataset\n",
"from azureml.opendatasets import MNIST\n",
"\n",
"data_folder = os.path.join(os.getcwd(), \"data\")\n",
"data_folder = os.path.join(os.getcwd(), \"/tmp/qs_data\")\n",
"os.makedirs(data_folder, exist_ok=True)\n",
"\n",
"mnist_file_dataset = MNIST.get_file_dataset()\n",
"mnist_file_dataset.download(data_folder, overwrite=True)\n",
"\n",
"mnist_file_dataset = mnist_file_dataset.register(\n",
" workspace=ws,\n",
" name=\"mnist_opendataset\",\n",
" description=\"training and test dataset\",\n",
" create_new_version=True,\n",
")"
"mnist_file_dataset.download(data_folder, overwrite=True)"
]
},
{
@@ -157,20 +84,7 @@
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612965929041
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"metadata": {},
"outputs": [],
"source": [
"from utils import load_data\n",
@@ -236,13 +150,13 @@
}
},
"source": [
"## Train model and log metrics\n",
"## Train model and log metrics with MLflow\n",
"\n",
"You'll train the model using the code below. Your training runs and metrics will be registered in the experiment you created, so that this information is available after you've finished.\n",
"You'll train the model using the code below. Note that you are using MLflow autologging to track metrics and log model artefacts.\n",
"\n",
"You'll be using the [LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) classifier from the [SciKit Learn framework](https://scikit-learn.org/) to classify the data.\n",
"\n",
"> **Note: The model training takes around 1 minute to complete.**"
"**Note: The model training takes approximately 2 minutes to complete.**"
]
},
{
@@ -265,41 +179,43 @@
"outputs": [],
"source": [
"# create the model\n",
"import mlflow\n",
"import numpy as np\n",
"from sklearn.linear_model import LogisticRegression\n",
"from azureml.core import Workspace\n",
"\n",
"# connect to your workspace\n",
"ws = Workspace.from_config()\n",
"\n",
"# create experiment and start logging to a new run in the experiment\n",
"experiment_name = \"azure-ml-in10-mins-tutorial\"\n",
"\n",
"# set up MLflow to track the metrics\n",
"mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())\n",
"mlflow.set_experiment(experiment_name)\n",
"mlflow.autolog()\n",
"\n",
"# set up the Logistic regression model\n",
"reg = 0.5\n",
"clf = LogisticRegression(\n",
" C=1.0 / reg, solver=\"liblinear\", multi_class=\"auto\", random_state=42\n",
")\n",
"clf.fit(X_train, y_train)\n",
"\n",
"# make predictions using the test set and calculate the accuracy\n",
"y_hat = clf.predict(X_test)\n",
"\n",
"# calculate accuracy on the prediction\n",
"acc = np.average(y_hat == y_test)\n",
"print(\"Accuracy is\", acc)\n",
"\n",
"run.log(\"regularization rate\", np.float(reg))\n",
"run.log(\"accuracy\", np.float(acc))"
"# train the model\n",
"with mlflow.start_run() as run:\n",
" clf.fit(X_train, y_train)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## View Experiment\n",
"In the left-hand menu in Azure Machine Learning Studio, select __Experiments__ and then select your experiment (azure-ml-in10-mins-tutorial). An experiment is a grouping of many runs from a specified script or piece of code. Information for the run is stored under that experiment. If the name doesn't exist when you submit an experiment, if you select your run you will see various tabs containing metrics, logs, explanations, etc.\n",
"\n",
"## Version control your models with the model registry\n",
"\n",
"You can use model registration to store and version your models in your workspace. Registered models are identified by name and version. Each time you register a model with the same name as an existing one, the registry increments the version. Azure Machine Learning supports any model that can be loaded through Python 3.\n",
"\n",
"The code below:\n",
"\n",
"1. Saves the model to disk\n",
"1. Uploads the model file to the run \n",
"1. Registers the uploaded model file\n",
"1. Transitions the run to a completed state"
"You can use model registration to store and version your models in your workspace. Registered models are identified by name and version. Each time you register a model with the same name as an existing one, the registry increments the version. The code below registers and versions the model you trained above. Once you have executed the code cell below you will be able to see the model in the registry by selecting __Models__ in the left-hand menu in Azure Machine Learning Studio."
]
},
{
@@ -321,30 +237,20 @@
},
"outputs": [],
"source": [
"import joblib\n",
"from azureml.core.model import Model\n",
"\n",
"path = \"sklearn_mnist_model.pkl\"\n",
"joblib.dump(value=clf, filename=path)\n",
"\n",
"run.upload_file(name=path, path_or_stream=path)\n",
"\n",
"model = run.register_model(\n",
" model_name=\"sklearn_mnist_model\",\n",
" model_path=path,\n",
" description=\"Mnist handwriting recognition\",\n",
")\n",
"\n",
"run.complete()"
"# register the model\n",
"model_uri = \"runs:/{}/model\".format(run.info.run_id)\n",
"model = mlflow.register_model(model_uri, \"sklearn_mnist_model\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Deploy the model\n",
"## Deploy the model for real-time inference\n",
"In this section you learn how to deploy a model so that an application can consume (inference) the model over REST.\n",
"\n",
"The next cell deploys the model to an Azure Container Instance so that you can score data in real-time (Azure Machine Learning also provides mechanisms to do batch scoring). A real-time endpoint allows application developers to integrate machine learning into their apps."
"### Create deployment configuration\n",
"The code cell gets a _curated environment_, which specifies all the dependencies required to host the model (for example, the packages like scikit-learn). Also, you create a _deployment configuration_, which specifies the amount of compute required to host the model. In this case, the compute will have 1CPU and 1GB memory."
]
},
{
@@ -369,22 +275,17 @@
"# create environment for the deploy\n",
"from azureml.core.environment import Environment\n",
"from azureml.core.conda_dependencies import CondaDependencies\n",
"\n",
"# to install required packages\n",
"env = Environment(\"quickstart-env\")\n",
"cd = CondaDependencies.create(\n",
" pip_packages=[\"azureml-dataset-runtime[pandas,fuse]\", \"azureml-defaults\"],\n",
" conda_packages=[\"scikit-learn==0.22.1\"],\n",
")\n",
"\n",
"env.python.conda_dependencies = cd\n",
"\n",
"# Register environment to re-use later\n",
"env.register(workspace=ws)\n",
"\n",
"# create config file\n",
"from azureml.core.webservice import AciWebservice\n",
"\n",
"# get a curated environment\n",
"env = Environment.get(\n",
" workspace=ws, \n",
" name=\"AzureML-sklearn-0.24.1-ubuntu18.04-py37-cpu-inference\",\n",
" version=1\n",
")\n",
"env.inferencing_stack_version='latest'\n",
"\n",
"# create deployment config i.e. compute resources\n",
"aciconfig = AciWebservice.deploy_configuration(\n",
" cpu_cores=1,\n",
" memory_gb=1,\n",
@@ -403,7 +304,11 @@
}
},
"source": [
"> **Note: The deployment takes around 3 minutes to complete.**"
"### Deploy model\n",
"\n",
"This next code cell deploys the model to Azure Container Instance (ACI).\n",
"\n",
"**Note: The deployment takes approximately 3 minutes to complete.**"
]
},
{
@@ -424,19 +329,17 @@
"source": [
"%%time\n",
"import uuid\n",
"from azureml.core.webservice import Webservice\n",
"from azureml.core.model import InferenceConfig\n",
"from azureml.core.environment import Environment\n",
"from azureml.core import Workspace\n",
"from azureml.core.model import Model\n",
"\n",
"ws = Workspace.from_config()\n",
"# get the registered model\n",
"model = Model(ws, \"sklearn_mnist_model\")\n",
"\n",
"# create an inference config i.e. the scoring script and environment\n",
"inference_config = InferenceConfig(entry_script=\"score.py\", environment=env)\n",
"\n",
"myenv = Environment.get(workspace=ws, name=\"quickstart-env\", version=\"1\")\n",
"inference_config = InferenceConfig(entry_script=\"score.py\", environment=myenv)\n",
"\n",
"# deploy the service\n",
"service_name = \"sklearn-mnist-svc-\" + str(uuid.uuid4())[:4]\n",
"service = Model.deploy(\n",
" workspace=ws,\n",
@@ -456,7 +359,10 @@
"The [*scoring script*](score.py) file referenced in the code above can be found in the same folder as this notebook, and has two functions:\n",
"\n",
"1. an `init` function that executes once when the service starts - in this function you normally get the model from the registry and set global variables\n",
"1. a `run(data)` function that executes each time a call is made to the service. In this function, you normally format the input data, run a prediction, and output the predicted result."
"1. a `run(data)` function that executes each time a call is made to the service. In this function, you normally format the input data, run a prediction, and output the predicted result.\n",
"\n",
"### View Endpoint\n",
"Once the model has been successfully deployed, you can view the endpoint by navigating to __Endpoints__ in the left-hand menu in Azure Machine Learning Studio. You will be able to see the state of the endpoint (healthy/unhealthy), logs, and consume (how applications can consume the model)."
]
},
{
@@ -474,29 +380,6 @@
"You can test the model by sending a raw HTTP request to test the web service. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612881527399
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"# scoring web service HTTP endpoint\n",
"print(service.scoring_uri)"
]
},
{
"cell_type": "code",
"execution_count": null,
@@ -525,56 +408,13 @@
"\n",
"headers = {\"Content-Type\": \"application/json\"}\n",
"\n",
"# for AKS deployment you'd need to the service key in the header as well\n",
"# api_key = service.get_key()\n",
"# headers = {'Content-Type':'application/json', 'Authorization':('Bearer '+ api_key)}\n",
"\n",
"resp = requests.post(service.scoring_uri, input_data, headers=headers)\n",
"\n",
"print(\"POST to url\", service.scoring_uri)\n",
"# print(\"input data:\", input_data)\n",
"print(\"label:\", y_test[random_index])\n",
"print(\"prediction:\", resp.text)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"\n",
"### View the results of your training\n",
"\n",
"When you're finished with an experiment run, you can always return to view the results of your model training here in the Azure Machine Learning studio:\n",
"\n",
"1. Select **Experiments** (left-hand menu)\n",
"1. Select **azure-ml-in10-mins-tutorial**\n",
"1. Select **Run 1**\n",
"1. Select the **Metrics** Tab\n",
"\n",
"The metrics tab will display the parameter values that were logged to the run."
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"### View the model in the model registry\n",
"\n",
"You can see the stored model by navigating to **Models** in the left-hand menu bar. Select the **sklearn_mnist_model** to see the details of the model, including the experiment run ID that created the model."
]
},
{
"cell_type": "markdown",
"metadata": {},

2
tutorials/compute-instance-quickstarts/quickstart-azureml-in-10mins/score.py
View File

@@ -9,7 +9,7 @@ def init():
# AZUREML_MODEL_DIR is an environment variable created during deployment.
# It is the path to the model folder (./azureml-models/$MODEL_NAME/$VERSION)
# For multiple models, it points to the folder containing all deployed models (./azureml-models)
model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "sklearn_mnist_model.pkl")
model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model/model.pkl")
model = joblib.load(model_path)

439
tutorials/compute-instance-quickstarts/quickstart-azureml-python-sdk/quickstart-azureml-python-sdk.ipynb
View File

@@ -17,12 +17,9 @@
}
},
"source": [
"# Quickstart: Learn how to get started with Azure ML Job Submission\n",
"# Quickstart: Learn how to submit batch jobs with the Azure Machine Learning Python SDK\n",
"\n",
"In this quickstart, you train a machine learning model by submitting a Job to a compute target. \n",
"When training, it is common to start on your local computer, and then later scale out to a cloud-based cluster. \n",
"\n",
"All you need to do is define the environment for each compute target within a script run configuration. Then, when you want to run your training experiment on a different compute target, specify the run configuration for that compute.\n",
"In this quickstart, you learn how to submit a batch training job using the Python SDK. In this example, we submit the job to the 'local' machine (the compute instance you are running this notebook on). However, you can use exactly the same method to submit the job to different compute targets (for example, AKS, Azure Machine Learning Compute Cluster, Synapse, etc) by changing a single line of code. A full list of support compute targets can be viewed [here](https://docs.microsoft.com/en-us/azure/machine-learning/concept-compute-target). \n",
"\n",
"This quickstart trains a simple logistic regression using the [MNIST](https://azure.microsoft.com/services/open-datasets/catalog/mnist/) dataset and [scikit-learn](http://scikit-learn.org) with Azure Machine Learning. MNIST is a popular dataset consisting of 70,000 grayscale images. Each image is a handwritten digit of 28x28 pixels, representing a number from 0 to 9. The goal is to create a multi-class classifier to identify the digit a given image represents. \n",
"\n",
@@ -30,6 +27,7 @@
"\n",
"> * Download a dataset and look at the data\n",
"> * Train an image classification model by submitting a batch job to a compute resource\n",
"> * Use MLflow autologging to track model metrics and log the model artefact\n",
"> * Review training results, find and register the best model"
]
},
@@ -67,16 +65,14 @@
},
"outputs": [],
"source": [
"import numpy as np\r\n",
"import matplotlib.pyplot as plt\r\n",
"\r\n",
"from azureml.core import Workspace\r\n",
"from azureml.core import Experiment\r\n",
"\r\n",
"# connect to your workspace\r\n",
"ws = Workspace.from_config()\r\n",
"\r\n",
"experiment_name = \"get-started-with-jobsubmission-tutorial\"\r\n",
"\n",
"from azureml.core import Workspace\n",
"from azureml.core import Experiment\n",
"\n",
"# connect to your workspace\n",
"ws = Workspace.from_config()\n",
"\n",
"experiment_name = \"get-started-with-jobsubmission-tutorial\"\n",
"exp = Experiment(workspace=ws, name=experiment_name)"
]
},
@@ -90,14 +86,7 @@
}
},
"source": [
"## Import Data\n",
"\n",
"Before you train a model, you need to understand the data that you are using to train it. In this section you will:\n",
"\n",
"* Download the MNIST dataset\n",
"* Display some sample images\n",
"\n",
"### Download the MNIST dataset\n",
"### The MNIST dataset\n",
"\n",
"Use Azure Open Datasets to get the raw MNIST data files. [Azure Open Datasets](https://docs.microsoft.com/azure/open-datasets/overview-what-are-open-datasets) are curated public datasets that you can use to add scenario-specific features to machine learning solutions for more accurate models. Each dataset has a corresponding class, `MNIST` in this case, to retrieve the data in different ways.\n",
"\n",
@@ -123,215 +112,16 @@
},
"outputs": [],
"source": [
"import os\n",
"from azureml.core import Dataset\n",
"from azureml.opendatasets import MNIST\n",
"\n",
"data_folder = os.path.join(os.getcwd(), \"data\")\n",
"os.makedirs(data_folder, exist_ok=True)\n",
"\n",
"mnist_file_dataset = MNIST.get_file_dataset()\n",
"mnist_file_dataset.download(data_folder, overwrite=True)\n",
"\n",
"mnist_file_dataset = mnist_file_dataset.register(\n",
" workspace=ws,\n",
" name=\"mnist_opendataset\",\n",
" description=\"training and test dataset\",\n",
" create_new_version=True,\n",
")"
"mnist_file_dataset = MNIST.get_file_dataset()"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"### Take a look at the data\n",
"You will load the compressed files into `numpy` arrays. Then use `matplotlib` to plot 30 random images from the dataset with their labels above them. Note this step requires a `load_data` function that's included in an `utils.py` file. This file is placed in the same folder as this notebook. The `load_data` function simply parses the compressed files into numpy arrays. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612965857960
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"# make sure utils.py is in the same directory as this code\r\n",
"from src.utils import load_data\r\n",
"import glob\r\n",
"\r\n",
"\r\n",
"# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.\r\n",
"X_train = (\r\n",
" load_data(\r\n",
" glob.glob(\r\n",
" os.path.join(data_folder, \"**/train-images-idx3-ubyte.gz\"), recursive=True\r\n",
" )[0],\r\n",
" False,\r\n",
" )\r\n",
" / 255.0\r\n",
")\r\n",
"X_test = (\r\n",
" load_data(\r\n",
" glob.glob(\r\n",
" os.path.join(data_folder, \"**/t10k-images-idx3-ubyte.gz\"), recursive=True\r\n",
" )[0],\r\n",
" False,\r\n",
" )\r\n",
" / 255.0\r\n",
")\r\n",
"y_train = load_data(\r\n",
" glob.glob(\r\n",
" os.path.join(data_folder, \"**/train-labels-idx1-ubyte.gz\"), recursive=True\r\n",
" )[0],\r\n",
" True,\r\n",
").reshape(-1)\r\n",
"y_test = load_data(\r\n",
" glob.glob(\r\n",
" os.path.join(data_folder, \"**/t10k-labels-idx1-ubyte.gz\"), recursive=True\r\n",
" )[0],\r\n",
" True,\r\n",
").reshape(-1)\r\n",
"\r\n",
"\r\n",
"# now let's show some randomly chosen images from the training set.\r\n",
"count = 0\r\n",
"sample_size = 30\r\n",
"plt.figure(figsize=(16, 6))\r\n",
"for i in np.random.permutation(X_train.shape[0])[:sample_size]:\r\n",
" count = count + 1\r\n",
" plt.subplot(1, sample_size, count)\r\n",
" plt.axhline(\"\")\r\n",
" plt.axvline(\"\")\r\n",
" plt.text(x=10, y=-10, s=y_train[i], fontsize=18)\r\n",
" plt.imshow(X_train[i].reshape(28, 28), cmap=plt.cm.Greys)\r\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"## Submit your training job\n",
"\n",
"In this quickstart you submit a job to run on the local compute, but you can use the same code to submit this training job to other compute targets. With Azure Machine Learning, you can run your script on various compute targets without having to change your training script. \n",
"\n",
"To submit a job you need:\n",
"* A directory\n",
"* A training script\n",
"* Create a script run configuration\n",
"* Submit the job \n",
"\n",
"\n",
"### Directory and training script \n",
"\n",
"You need a directory to deliver the necessary code from your computer to the remote resource. A directory with a training script has been created for you and can be found in the same folder as this notebook.\n",
"\n",
"Take a few minutes to examine the training script."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612965865707
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"with open(\"./src/train.py\", \"r\") as f:\n",
" print(f.read())"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"Notice how the script gets data and saves models:\n",
"\n",
"+ The training script reads an argument to find the directory containing the data. When you submit the job later, you point to the dataset for this argument:\n",
"`parser.add_argument('--data-folder', type=str, dest='data_folder', help='data directory mounting point')`\n",
"\n",
"\n",
"+ The training script saves your model into a directory named outputs. <br/>\n",
"`joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')`<br/>\n",
"Anything written in this directory is automatically uploaded into your workspace. You'll access your model from this directory later in the tutorial.\n",
"\n",
"The file `utils.py` is referenced from the training script to load the dataset correctly. This script is also copied into the script folder so that it can be accessed along with the training script."
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"### Configure the training job\n",
"\n",
"Create a [ScriptRunConfig]() object to specify the configuration details of your training job, including your training script, environment to use, and the compute target to run on. Configure the ScriptRunConfig by specifying:\n",
"\n",
"* The directory that contains your scripts. All the files in this directory are uploaded into the cluster nodes for execution. \n",
"* The compute target. In this case you will point to local compute\n",
"* The training script name, train.py\n",
"* An environment that contains the libraries needed to run the script\n",
"* Arguments required from the training script. \n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"metadata": {},
"source": [
"### Define the Environment\n",
"An Environment defines Python packages, environment variables, and Docker settings that are used in machine learning experiments. Here you will be using a curated environment that has already been made available through the workspace. \n",
"\n",
"Read [this article](https://docs.microsoft.com/azure/machine-learning/how-to-use-environments) if you want to learn more about Environments and how to use them."
@@ -357,11 +147,12 @@
"outputs": [],
"source": [
"from azureml.core.environment import Environment\n",
"from azureml.core.conda_dependencies import CondaDependencies\n",
"\n",
"# use a curated environment that has already been built for you\n",
"\n",
"env = Environment.get(workspace=ws, name=\"AzureML-Scikit-learn-0.20.3\")"
"env = Environment.get(workspace=ws, \n",
" name=\"AzureML-Scikit-learn0.24-Cuda11-OpenMpi4.1.0-py36\", \n",
" version=1)"
]
},
{
@@ -374,9 +165,17 @@
}
},
"source": [
"Create a [ScriptRunConfig](https://docs.microsoft.com/python/api/azureml-core/azureml.core.scriptrunconfig?preserve-view=true&view=azure-ml-py) object to specify the configuration details of your training job, including your training script, environment to use, and the compute target to run on. A script run configuration is used to configure the information necessary for submitting a training run as part of an experiment. In this case we will run this on a 'local' compute target, which is the compute instance you are running this notebook on.\r\n",
"\r\n",
"Read more about configuring and submitting training runs [here](https://docs.microsoft.com/azure/machine-learning/how-to-set-up-training-targets). "
"### Configure the training job\n",
"\n",
"Create a [ScriptRunConfig](https://docs.microsoft.com/python/api/azureml-core/azureml.core.script_run_config.scriptrunconfig?view=azure-ml-py) object to specify the configuration details of your training job, including your training script, environment to use, and the compute target to run on. Configure the ScriptRunConfig by specifying:\n",
"\n",
"* The directory that contains your scripts. All the files in this directory are uploaded into the cluster nodes for execution. \n",
"* The compute target. In this case you will point to local compute\n",
"* The training script name, train.py\n",
"* An environment that contains the libraries needed to run the script\n",
"* Arguments required from the training script. \n",
"\n",
"In this run we will be submitting to \"local\", which is the compute instance you are running this notebook. If you have another compute target (for example: AKS, Azure ML Compute Cluster, Azure Databricks, etc) then you just need to change the `compute_target` argument below. You can learn more about other compute targets [here](https://docs.microsoft.com/azure/machine-learning/how-to-set-up-training-targets). "
]
},
{
@@ -423,7 +222,7 @@
"source": [
"### Submit the job\n",
"\n",
"Run the experiment by submitting the ScriptRunConfig object. After this there are many options for monitoring your run. You can either navigate to the experiment \"get-started-with-jobsubmission-tutorial\" in the left menu item Experiments to monitor the run (quick link to the run details page in the cell output below), or you can monitor the run inline in this notebook by using the Jupyter widget activated below."
"Run the experiment by submitting the ScriptRunConfig object. After this there are many options for monitoring your run. Once submitted, you can either navigate to the experiment \"get-started-with-jobsubmission-tutorial\" in the left menu item __Experiments__ to monitor the run, or you can monitor the run inline as the `run.wait_for_completion(show_output=True)` will stream the logs of the run. You will see that the environment is built for you to ensure reproducibility - this adds a couple of minutes to the run time. On subsequent runs, the environment is re-used making the runtime shorter."
]
},
{
@@ -446,137 +245,9 @@
"outputs": [],
"source": [
"run = exp.submit(config=src)\n",
"run"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"### Jupyter widget\n",
"\n",
"Watch the progress of the run with a Jupyter widget. Like the run submission, the widget is asynchronous and provides live updates every 10-15 seconds until the job completes.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612966026710
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"from azureml.widgets import RunDetails\n",
"\n",
"RunDetails(run).show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"if you want to cancel a run, you can follow [these instructions](https://aka.ms/aml-docs-cancel-run)."
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"### Get log results upon completion\n",
"\n",
"Model training happens in the background. You can use `wait_for_completion` to block and wait until the model has completed training before running more code. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612966045110
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"# specify show_output to True for a verbose log\n",
"run.wait_for_completion(show_output=True)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"### Display run results\n",
"\n",
"You now have a trained model. Retrieve all the metrics logged during the run, including the accuracy of the model:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612966059052
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"print(run.get_metrics())"
]
},
{
"cell_type": "markdown",
"metadata": {
@@ -589,42 +260,11 @@
"source": [
"## Register model\n",
"\n",
"The last step in the training script wrote the file `outputs/sklearn_mnist_model.pkl` in a directory named `outputs` on the compute where the job is executed. `outputs` is a special directory in that all content in this directory is automatically uploaded to your workspace. This content appears in the run record in the experiment under your workspace. Hence, the model file is now also available in your workspace."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"gather": {
"logged": 1612966064041
},
"jupyter": {
"outputs_hidden": false,
"source_hidden": false
},
"nteract": {
"transient": {
"deleting": false
}
}
},
"outputs": [],
"source": [
"print(run.get_file_names())"
]
},
{
"cell_type": "markdown",
"metadata": {
"nteract": {
"transient": {
"deleting": false
}
}
},
"source": [
"Register the model in the workspace so that you (or your team members with access to the workspace) can later query, examine, and deploy this model."
"The training script used the MLflow autologging feature and therefore the model was captured and stored on your behalf. Below we register the model into the Azure Machine Learning Model registry, which lets you keep track of all the models in your Azure Machine Learning workspace.\n",
"\n",
"Models are identified by name and version. Each time you register a model with the same name as an existing one, the registry assumes that it's a new version. The version is incremented, and the new model is registered under the same name.\n",
"\n",
"When you register the model, you can provide additional metadata tags and then use the tags when you search for models."
]
},
{
@@ -648,11 +288,18 @@
"source": [
"# register model\n",
"model = run.register_model(\n",
" model_name=\"sklearn_mnist\", model_path=\"outputs/sklearn_mnist_model.pkl\"\n",
" model_name=\"sklearn_mnist\", model_path=\"model/model.pkl\"\n",
")\n",
"print(model.name, model.id, model.version, sep=\"\\t\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You will now be able to see the model in the regsitry by selecting __Models__ in the left-hand menu of the Azure Machine Learning Studio."
]
},
{
"cell_type": "markdown",
"metadata": {

16
tutorials/compute-instance-quickstarts/quickstart-azureml-python-sdk/src/train.py
View File

@@ -2,11 +2,10 @@ import argparse
import os
import numpy as np
import glob
import joblib
import mlflow
from sklearn.linear_model import LogisticRegression
import joblib
from azureml.core import Run
from utils import load_data
# let user feed in 2 parameters, the dataset to mount or download,
@@ -58,8 +57,8 @@ y_test = load_data(
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape, sep="\n")
# get hold of the current run
run = Run.get_context()
# use mlflow autologging
mlflow.autolog()
print("Train a logistic regression model with regularization rate of", args.reg)
clf = LogisticRegression(
@@ -73,10 +72,3 @@ y_hat = clf.predict(X_test)
# calculate accuracy on the prediction
acc = np.average(y_hat == y_test)
print("Accuracy is", acc)
run.log("regularization rate", np.float(args.reg))
run.log("accuracy", np.float(acc))
os.makedirs("outputs", exist_ok=True)
# note file saved in the outputs folder is automatically uploaded into experiment record
joblib.dump(value=clf, filename="outputs/sklearn_mnist_model.pkl")