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

Add synapse sample notebooks

NBSETUP.md

@@ -28,7 +28,7 @@ git clone https://github.com/Azure/MachineLearningNotebooks.git
 pip install azureml-sdk[notebooks,tensorboard]
 
 # install model explainability component
-pip install azureml-sdk[explain]
+pip install azureml-sdk[interpret]
 
 # install automated ml components
 pip install azureml-sdk[automl]
@@ -86,7 +86,7 @@ If you need additional Azure ML SDK components, you can either modify the Docker
 pip install azureml-sdk[automl]
 
 # install the core SDK and model explainability component
-pip install azureml-sdk[explain]
+pip install azureml-sdk[interpret]
 
 # install the core SDK and experimental components
 pip install azureml-sdk[contrib]

README.md

@@ -2,7 +2,7 @@
 
 > a community-driven repository of examples using mlflow for tracking can be found at https://github.com/Azure/azureml-examples
 
-This repository contains example notebooks demonstrating the [Azure Machine Learning](https://azure.microsoft.com/en-us/services/machine-learning-service/) Python SDK which allows you to build, train, deploy and manage machine learning solutions using Azure.  The AML SDK allows you the choice of using local or cloud compute resources, while managing and maintaining the complete data science workflow from the cloud.
+This repository contains example notebooks demonstrating the [Azure Machine Learning](https://azure.microsoft.com/services/machine-learning-service/) Python SDK which allows you to build, train, deploy and manage machine learning solutions using Azure.  The AML SDK allows you the choice of using local or cloud compute resources, while managing and maintaining the complete data science workflow from the cloud.
 
 ![Azure ML Workflow](https://raw.githubusercontent.com/MicrosoftDocs/azure-docs/master/articles/machine-learning/media/concept-azure-machine-learning-architecture/workflow.png)
 
@@ -20,10 +20,10 @@ This [index](./index.md) should assist in navigating the Azure Machine Learning
 If you want to...
 
  * ...try out and explore Azure ML, start with image classification tutorials: [Part 1 (Training)](./tutorials/image-classification-mnist-data/img-classification-part1-training.ipynb) and [Part 2 (Deployment)](./tutorials/image-classification-mnist-data/img-classification-part2-deploy.ipynb).
- * ...learn about experimentation and tracking run history, first [train within Notebook](./how-to-use-azureml/training/train-within-notebook/train-within-notebook.ipynb), then try [training on remote VM](./how-to-use-azureml/training/train-on-remote-vm/train-on-remote-vm.ipynb) and [using logging APIs](./how-to-use-azureml/training/logging-api/logging-api.ipynb).
- * ...train deep learning models at scale, first learn about [Machine Learning Compute](./how-to-use-azureml/training/train-on-amlcompute/train-on-amlcompute.ipynb), and then try [distributed hyperparameter tuning](./how-to-use-azureml/training-with-deep-learning/train-hyperparameter-tune-deploy-with-pytorch/train-hyperparameter-tune-deploy-with-pytorch.ipynb) and [distributed training](./how-to-use-azureml/training-with-deep-learning/distributed-pytorch-with-horovod/distributed-pytorch-with-horovod.ipynb).
- * ...deploy models as a realtime scoring service, first learn the basics by [training within Notebook and deploying to Azure Container Instance](./how-to-use-azureml/training/train-within-notebook/train-within-notebook.ipynb), then learn how to [production deploy models on Azure Kubernetes Cluster](./how-to-use-azureml/deployment/production-deploy-to-aks/production-deploy-to-aks.ipynb).
- * ...deploy models as a batch scoring service, first [train a model within Notebook](./how-to-use-azureml/training/train-within-notebook/train-within-notebook.ipynb), then [create Machine Learning Compute for scoring compute](./how-to-use-azureml/training/train-on-amlcompute/train-on-amlcompute.ipynb), and [use Machine Learning Pipelines to deploy your model](https://aka.ms/pl-batch-scoring).
+ * ...learn about experimentation and tracking run history: [track and monitor experiments](./how-to-use-azureml/track-and-monitor-experiments).
+ * ...train deep learning models at scale, first learn about [Machine Learning Compute](./how-to-use-azureml/training/train-on-amlcompute/train-on-amlcompute.ipynb), and then try [distributed hyperparameter tuning](./how-to-use-azureml/ml-frameworks/pytorch/train-hyperparameter-tune-deploy-with-pytorch/train-hyperparameter-tune-deploy-with-pytorch.ipynb) and [distributed training](./how-to-use-azureml/ml-frameworks/pytorch/distributed-pytorch-with-horovod/distributed-pytorch-with-horovod.ipynb).
+ * ...deploy models as a realtime scoring service, first learn the basics by [deploying to Azure Container Instance](./how-to-use-azureml/deployment/deploy-to-cloud/model-register-and-deploy.ipynb), then learn how to [production deploy models on Azure Kubernetes Cluster](./how-to-use-azureml/deployment/production-deploy-to-aks/production-deploy-to-aks.ipynb).
+ * ...deploy models as a batch scoring service: [create Machine Learning Compute for scoring compute](./how-to-use-azureml/training/train-on-amlcompute/train-on-amlcompute.ipynb) and [use Machine Learning Pipelines to deploy your model](https://aka.ms/pl-batch-scoring).
  * ...monitor your deployed models, learn about using [App Insights](./how-to-use-azureml/deployment/enable-app-insights-in-production-service/enable-app-insights-in-production-service.ipynb).
 
 ## Tutorials
@@ -35,13 +35,12 @@ The [Tutorials](./tutorials) folder contains notebooks for the tutorials describ
 The [How to use Azure ML](./how-to-use-azureml) folder contains specific examples demonstrating the features of the Azure Machine Learning SDK
 
 - [Training](./how-to-use-azureml/training) - Examples of how to build models using Azure ML's logging and execution capabilities on local and remote compute targets
-- [Training with Deep Learning](./how-to-use-azureml/training-with-deep-learning) - Examples demonstrating how to build deep learning models using estimators and parameter sweeps
+- [Training with ML and DL frameworks](./how-to-use-azureml/ml-frameworks) - Examples demonstrating how to build and train machine learning models at scale on Azure ML and perform hyperparameter tuning.
 - [Manage Azure ML Service](./how-to-use-azureml/manage-azureml-service) - Examples how to perform tasks, such as authenticate against Azure ML service in different ways.
 - [Automated Machine Learning](./how-to-use-azureml/automated-machine-learning) - Examples using Automated Machine Learning to automatically generate optimal machine learning pipelines and models
 - [Machine Learning Pipelines](./how-to-use-azureml/machine-learning-pipelines) - Examples showing how to create and use reusable pipelines for training and batch scoring
 - [Deployment](./how-to-use-azureml/deployment) - Examples showing how to deploy and manage machine learning models and solutions
 - [Azure Databricks](./how-to-use-azureml/azure-databricks) - Examples showing how to use Azure ML with Azure Databricks
-- [Monitor Models](./how-to-use-azureml/monitor-models) - Examples showing how to enable model monitoring services such as DataDrift
 - [Reinforcement Learning](./how-to-use-azureml/reinforcement-learning) - Examples showing how to train reinforcement learning agents
 
 ---
@@ -60,7 +59,6 @@ Visit this [community repository](https://github.com/microsoft/MLOps/tree/master
 ## Projects using Azure Machine Learning
 
 Visit following repos to see projects contributed by Azure ML users:
- - [AMLSamples](https://github.com/Azure/AMLSamples) Number of end-to-end examples, including face recognition, predictive maintenance, customer churn and sentiment analysis.
  - [Learn about Natural Language Processing best practices using Azure Machine Learning service](https://github.com/microsoft/nlp)
  - [Pre-Train BERT models using Azure Machine Learning service](https://github.com/Microsoft/AzureML-BERT)
  - [Fashion MNIST with Azure ML SDK](https://github.com/amynic/azureml-sdk-fashion)

configuration.ipynb

@@ -103,7 +103,7 @@
       "source": [
         "import azureml.core\n",
         "\n",
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

contrib/fairness/fairlearn-azureml-mitigation.ipynb

@@ -38,7 +38,7 @@
         "## Introduction\n",
         "This notebook shows how to use [Fairlearn (an open source fairness assessment and unfairness mitigation package)](http://fairlearn.github.io) and Azure Machine Learning Studio for a binary classification problem. This example uses the well-known adult census dataset. For the purposes of this notebook, we shall treat this as a loan decision problem. We will pretend that the label indicates whether or not each individual repaid a loan in the past. We will use the data to train a predictor to predict whether previously unseen individuals will repay a loan or not. The assumption is that the model predictions are used to decide whether an individual should be offered a loan. Its purpose is purely illustrative of a workflow including a fairness dashboard - in particular, we do **not** include a full discussion of the detailed issues which arise when considering fairness in machine learning. For such discussions, please [refer to the Fairlearn website](http://fairlearn.github.io/).\n",
         "\n",
-        "We will apply the [grid search algorithm](https://fairlearn.github.io/api_reference/fairlearn.reductions.html#fairlearn.reductions.GridSearch) from the Fairlearn package using a specific notion of fairness called Demographic Parity. This produces a set of models, and we will view these in a dashboard both locally and in the Azure Machine Learning Studio.\n",
+        "We will apply the [grid search algorithm](https://fairlearn.github.io/master/api_reference/fairlearn.reductions.html#fairlearn.reductions.GridSearch) from the Fairlearn package using a specific notion of fairness called Demographic Parity. This produces a set of models, and we will view these in a dashboard both locally and in the Azure Machine Learning Studio.\n",
         "\n",
         "### Setup\n",
         "\n",
@@ -46,7 +46,7 @@
         "Please see the [configuration notebook](../../configuration.ipynb) for information about creating one, if required.\n",
         "This notebook also requires the following packages:\n",
         "* `azureml-contrib-fairness`\n",
-        "* `fairlearn==0.4.6`\n",
+        "* `fairlearn==0.4.6` (v0.5.0 will work with minor modifications)\n",
         "* `joblib`\n",
         "* `shap`\n",
         "\n",
@@ -62,13 +62,20 @@
         "# !pip install --upgrade scikit-learn>=0.22.1"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Finally, please ensure that when you downloaded this notebook, you also downloaded the `fairness_nb_utils.py` file from the same location, and placed it in the same directory as this notebook."
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
         "<a id=\"LoadingData\"></a>\n",
         "## Loading the Data\n",
-        "We use the well-known `adult` census dataset, which we load using `shap` (for convenience). We start with a fairly unremarkable set of imports:"
+        "We use the well-known `adult` census dataset, which we will fetch from the OpenML website. We start with a fairly unremarkable set of imports:"
       ]
     },
     {
@@ -79,9 +86,16 @@
       "source": [
         "from fairlearn.reductions import GridSearch, DemographicParity, ErrorRate\n",
         "from fairlearn.widget import FairlearnDashboard\n",
-        "from sklearn import svm\n",
-        "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
+        "\n",
+        "from sklearn.compose import ColumnTransformer\n",
+        "from sklearn.datasets import fetch_openml\n",
+        "from sklearn.impute import SimpleImputer\n",
         "from sklearn.linear_model import LogisticRegression\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
+        "from sklearn.compose import make_column_selector as selector\n",
+        "from sklearn.pipeline import Pipeline\n",
+        "\n",
         "import pandas as pd"
       ]
     },
@@ -89,7 +103,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "We can now load and inspect the data from the `shap` package:"
+        "We can now load and inspect the data:"
       ]
     },
     {
@@ -98,10 +112,13 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from sklearn.datasets import fetch_openml\n",
-        "data = fetch_openml(data_id=1590, as_frame=True)\n",
+        "from fairness_nb_utils import fetch_openml_with_retries\n",
+        "\n",
+        "data = fetch_openml_with_retries(data_id=1590)\n",
+        "    \n",
+        "# Extract the items we want\n",
         "X_raw = data.data\n",
-        "Y = (data.target == '>50K') * 1\n",
+        "y = (data.target == '>50K') * 1\n",
         "\n",
         "X_raw[\"race\"].value_counts().to_dict()"
       ]
@@ -110,7 +127,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "We are going to treat the sex of each individual as a protected attribute (where 0 indicates female and 1 indicates male), and in this particular case we are going separate this attribute out and drop it from the main data (this is not always the best option - see the [Fairlearn website](http://fairlearn.github.io/) for further discussion). We also separate out the Race column, but we will not perform any mitigation based on it. Finally, we perform some standard data preprocessing steps to convert the data into a format suitable for the ML algorithms"
+        "We are going to treat the sex and race of each individual as protected attributes, and in this particular case we are going to remove these attributes from the main data (this is not always the best option - see the [Fairlearn website](http://fairlearn.github.io/) for further discussion). Protected attributes are often denoted by 'A' in the literature, and we follow that convention here:"
       ]
     },
     {
@@ -120,23 +137,14 @@
       "outputs": [],
       "source": [
         "A = X_raw[['sex','race']]\n",
-        "X = X_raw.drop(labels=['sex', 'race'],axis = 1)\n",
-        "X_dummies = pd.get_dummies(X)\n",
-        "\n",
-        "sc = StandardScaler()\n",
-        "X_scaled = sc.fit_transform(X_dummies)\n",
-        "X_scaled = pd.DataFrame(X_scaled, columns=X_dummies.columns)\n",
-        "\n",
-        "\n",
-        "le = LabelEncoder()\n",
-        "Y = le.fit_transform(Y)"
+        "X_raw = X_raw.drop(labels=['sex', 'race'],axis = 1)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "With our data prepared, we can make the conventional split in to 'test' and 'train' subsets:"
+        "We now preprocess our data. To avoid the problem of data leakage, we split our data into training and test sets before performing any other transformations. Subsequent transformations (such as scalings) will be fit to the training data set, and then applied to the test dataset."
       ]
     },
     {
@@ -145,21 +153,76 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from sklearn.model_selection import train_test_split\n",
-        "X_train, X_test, Y_train, Y_test, A_train, A_test = train_test_split(X_scaled, \n",
-        "                                                    Y, \n",
-        "                                                    A,\n",
-        "                                                    test_size = 0.2,\n",
-        "                                                    random_state=0,\n",
-        "                                                    stratify=Y)\n",
+        "(X_train, X_test, y_train, y_test, A_train, A_test) = train_test_split(\n",
+        "    X_raw, y, A, test_size=0.3, random_state=12345, stratify=y\n",
+        ")\n",
+        "\n",
+        "# Ensure indices are aligned between X, y and A,\n",
+        "# after all the slicing and splitting of DataFrames\n",
+        "# and Series\n",
         "\n",
-        "# Work around indexing issue\n",
         "X_train = X_train.reset_index(drop=True)\n",
-        "A_train = A_train.reset_index(drop=True)\n",
         "X_test = X_test.reset_index(drop=True)\n",
+        "y_train = y_train.reset_index(drop=True)\n",
+        "y_test = y_test.reset_index(drop=True)\n",
+        "A_train = A_train.reset_index(drop=True)\n",
         "A_test = A_test.reset_index(drop=True)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We have two types of column in the dataset - categorical columns which will need to be one-hot encoded, and numeric ones which will need to be rescaled. We also need to take care of missing values. We use a simple approach here, but please bear in mind that this is another way that bias could be introduced (especially if one subgroup tends to have more missing values).\n",
+        "\n",
+        "For this preprocessing, we make use of `Pipeline` objects from `sklearn`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "numeric_transformer = Pipeline(\n",
+        "    steps=[\n",
+        "        (\"impute\", SimpleImputer()),\n",
+        "        (\"scaler\", StandardScaler()),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "categorical_transformer = Pipeline(\n",
+        "    [\n",
+        "        (\"impute\", SimpleImputer(strategy=\"most_frequent\")),\n",
+        "        (\"ohe\", OneHotEncoder(handle_unknown=\"ignore\", sparse=False)),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "preprocessor = ColumnTransformer(\n",
+        "    transformers=[\n",
+        "        (\"num\", numeric_transformer, selector(dtype_exclude=\"category\")),\n",
+        "        (\"cat\", categorical_transformer, selector(dtype_include=\"category\")),\n",
+        "    ]\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now, the preprocessing pipeline is defined, we can run it on our training data, and apply the generated transform to our test data:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "X_train = preprocessor.fit_transform(X_train)\n",
+        "X_test = preprocessor.transform(X_test)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -178,7 +241,7 @@
       "source": [
         "unmitigated_predictor = LogisticRegression(solver='liblinear', fit_intercept=True)\n",
         "\n",
-        "unmitigated_predictor.fit(X_train, Y_train)"
+        "unmitigated_predictor.fit(X_train, y_train)"
       ]
     },
     {
@@ -195,7 +258,7 @@
       "outputs": [],
       "source": [
         "FairlearnDashboard(sensitive_features=A_test, sensitive_feature_names=['Sex', 'Race'],\n",
-        "                   y_true=Y_test,\n",
+        "                   y_true=y_test,\n",
         "                   y_pred={\"unmitigated\": unmitigated_predictor.predict(X_test)})"
       ]
     },
@@ -246,9 +309,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "sweep.fit(X_train, Y_train,\n",
+        "sweep.fit(X_train, y_train,\n",
         "          sensitive_features=A_train.sex)\n",
         "\n",
+        "# For Fairlearn v0.5.0, need sweep.predictors_\n",
         "predictors = sweep._predictors"
       ]
     },
@@ -270,9 +334,9 @@
         "    classifier = lambda X: m.predict(X)\n",
         "    \n",
         "    error = ErrorRate()\n",
-        "    error.load_data(X_train, pd.Series(Y_train), sensitive_features=A_train.sex)\n",
+        "    error.load_data(X_train, pd.Series(y_train), sensitive_features=A_train.sex)\n",
         "    disparity = DemographicParity()\n",
-        "    disparity.load_data(X_train, pd.Series(Y_train), sensitive_features=A_train.sex)\n",
+        "    disparity.load_data(X_train, pd.Series(y_train), sensitive_features=A_train.sex)\n",
         "    \n",
         "    errors.append(error.gamma(classifier)[0])\n",
         "    disparities.append(disparity.gamma(classifier).max())\n",
@@ -326,7 +390,7 @@
       "source": [
         "FairlearnDashboard(sensitive_features=A_test, \n",
         "                   sensitive_feature_names=['Sex', 'Race'],\n",
-        "                   y_true=Y_test.tolist(),\n",
+        "                   y_true=y_test.tolist(),\n",
         "                   y_pred=predictions_dominant)"
       ]
     },
@@ -334,7 +398,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "When using sex as the sensitive feature, we see a Pareto front forming - the set of predictors which represent optimal tradeoffs between accuracy and disparity in predictions. In the ideal case, we would have a predictor at (1,0) - perfectly accurate and without any unfairness under demographic parity (with respect to the protected attribute \"sex\"). The Pareto front represents the closest we can come to this ideal based on our data and choice of estimator. Note the range of the axes - the disparity axis covers more values than the accuracy, so we can reduce disparity substantially for a small loss in accuracy. Finally, we also see that the unmitigated model is towards the top right of the plot, with high accuracy, but worst disparity.\n",
+        "When using sex as the sensitive feature and accuracy as the metric, we see a Pareto front forming - the set of predictors which represent optimal tradeoffs between accuracy and disparity in predictions. In the ideal case, we would have a predictor at (1,0) - perfectly accurate and without any unfairness under demographic parity (with respect to the protected attribute \"sex\"). The Pareto front represents the closest we can come to this ideal based on our data and choice of estimator. Note the range of the axes - the disparity axis covers more values than the accuracy, so we can reduce disparity substantially for a small loss in accuracy. Finally, we also see that the unmitigated model is towards the top right of the plot, with high accuracy, but worst disparity.\n",
         "\n",
         "By clicking on individual models on the plot, we can inspect their metrics for disparity and accuracy in greater detail. In a real example, we would then pick the model which represented the best trade-off between accuracy and disparity given the relevant business constraints."
       ]
@@ -441,7 +505,7 @@
         "from fairlearn.metrics._group_metric_set import _create_group_metric_set\n",
         "\n",
         "\n",
-        "dash_dict = _create_group_metric_set(y_true=Y_test,\n",
+        "dash_dict = _create_group_metric_set(y_true=y_test,\n",
         "                                     predictions=predictions_dominant_ids,\n",
         "                                     sensitive_features=sf,\n",
         "                                     prediction_type='binary_classification')"

contrib/fairness/fairness_nb_utils.py

@@ -0,0 +1,28 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""Utilities for azureml-contrib-fairness notebooks."""
+
+from sklearn.datasets import fetch_openml
+import time
+
+
+def fetch_openml_with_retries(data_id, max_retries=4, retry_delay=60):
+    """Fetch a given dataset from OpenML with retries as specified."""
+    for i in range(max_retries):
+        try:
+            print("Download attempt {0} of {1}".format(i + 1, max_retries))
+            data = fetch_openml(data_id=data_id, as_frame=True)
+            break
+        except Exception as e:
+            print("Download attempt failed with exception:")
+            print(e)
+            if i + 1 != max_retries:
+                print("Will retry after {0} seconds".format(retry_delay))
+                time.sleep(retry_delay)
+                retry_delay = retry_delay * 2
+    else:
+        raise RuntimeError("Unable to download dataset from OpenML")
+
+    return data

contrib/fairness/upload-fairness-dashboard.ipynb

@@ -48,7 +48,7 @@
         "Please see the [configuration notebook](../../configuration.ipynb) for information about creating one, if required.\n",
         "This notebook also requires the following packages:\n",
         "* `azureml-contrib-fairness`\n",
-        "* `fairlearn==0.4.6`\n",
+        "* `fairlearn==0.4.6` (should also work with v0.5.0)\n",
         "* `joblib`\n",
         "* `shap`\n",
         "\n",
@@ -64,13 +64,20 @@
         "# !pip install --upgrade scikit-learn>=0.22.1"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Finally, please ensure that when you downloaded this notebook, you also downloaded the `fairness_nb_utils.py` file from the same location, and placed it in the same directory as this notebook."
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
         "<a id=\"LoadingData\"></a>\n",
         "## Loading the Data\n",
-        "We use the well-known `adult` census dataset, which we load using `shap` (for convenience). We start with a fairly unremarkable set of imports:"
+        "We use the well-known `adult` census dataset, which we fetch from the OpenML website. We start with a fairly unremarkable set of imports:"
       ]
     },
     {
@@ -80,9 +87,14 @@
       "outputs": [],
       "source": [
         "from sklearn import svm\n",
-        "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
+        "from sklearn.compose import ColumnTransformer\n",
+        "from sklearn.datasets import fetch_openml\n",
+        "from sklearn.impute import SimpleImputer\n",
         "from sklearn.linear_model import LogisticRegression\n",
-        "import pandas as pd"
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
+        "from sklearn.compose import make_column_selector as selector\n",
+        "from sklearn.pipeline import Pipeline"
       ]
     },
     {
@@ -98,10 +110,13 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from sklearn.datasets import fetch_openml\n",
-        "data = fetch_openml(data_id=1590, as_frame=True)\n",
+        "from fairness_nb_utils import fetch_openml_with_retries\n",
+        "\n",
+        "data = fetch_openml_with_retries(data_id=1590)\n",
+        "    \n",
+        "# Extract the items we want\n",
         "X_raw = data.data\n",
-        "Y = (data.target == '>50K') * 1"
+        "y = (data.target == '>50K') * 1"
       ]
     },
     {
@@ -127,7 +142,7 @@
         "<a id=\"ProcessingData\"></a>\n",
         "## Processing the Data\n",
         "\n",
-        "With the data loaded, we process it for our needs. First, we extract the sensitive features of interest into `A` (conventionally used in the literature) and put the rest of the feature data into `X`:"
+        "With the data loaded, we process it for our needs. First, we extract the sensitive features of interest into `A` (conventionally used in the literature) and leave the rest of the feature data in `X_raw`:"
       ]
     },
     {
@@ -137,15 +152,14 @@
       "outputs": [],
       "source": [
         "A = X_raw[['sex','race']]\n",
-        "X = X_raw.drop(labels=['sex', 'race'],axis = 1)\n",
-        "X_dummies = pd.get_dummies(X)"
+        "X_raw = X_raw.drop(labels=['sex', 'race'],axis = 1)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Next, we apply a standard set of scalings:"
+        "We now preprocess our data. To avoid the problem of data leakage, we split our data into training and test sets before performing any other transformations. Subsequent transformations (such as scalings) will be fit to the training data set, and then applied to the test dataset."
       ]
     },
     {
@@ -154,42 +168,76 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "sc = StandardScaler()\n",
-        "X_scaled = sc.fit_transform(X_dummies)\n",
-        "X_scaled = pd.DataFrame(X_scaled, columns=X_dummies.columns)\n",
+        "(X_train, X_test, y_train, y_test, A_train, A_test) = train_test_split(\n",
+        "    X_raw, y, A, test_size=0.3, random_state=12345, stratify=y\n",
+        ")\n",
         "\n",
-        "le = LabelEncoder()\n",
-        "Y = le.fit_transform(Y)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Finally, we can then split our data into training and test sets, and also make the labels on our test portion of `A` human-readable:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.model_selection import train_test_split\n",
-        "X_train, X_test, Y_train, Y_test, A_train, A_test = train_test_split(X_scaled, \n",
-        "                                                    Y, \n",
-        "                                                    A,\n",
-        "                                                    test_size = 0.2,\n",
-        "                                                    random_state=0,\n",
-        "                                                    stratify=Y)\n",
+        "# Ensure indices are aligned between X, y and A,\n",
+        "# after all the slicing and splitting of DataFrames\n",
+        "# and Series\n",
         "\n",
-        "# Work around indexing issue\n",
         "X_train = X_train.reset_index(drop=True)\n",
-        "A_train = A_train.reset_index(drop=True)\n",
         "X_test = X_test.reset_index(drop=True)\n",
+        "y_train = y_train.reset_index(drop=True)\n",
+        "y_test = y_test.reset_index(drop=True)\n",
+        "A_train = A_train.reset_index(drop=True)\n",
         "A_test = A_test.reset_index(drop=True)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We have two types of column in the dataset - categorical columns which will need to be one-hot encoded, and numeric ones which will need to be rescaled. We also need to take care of missing values. We use a simple approach here, but please bear in mind that this is another way that bias could be introduced (especially if one subgroup tends to have more missing values).\n",
+        "\n",
+        "For this preprocessing, we make use of `Pipeline` objects from `sklearn`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "numeric_transformer = Pipeline(\n",
+        "    steps=[\n",
+        "        (\"impute\", SimpleImputer()),\n",
+        "        (\"scaler\", StandardScaler()),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "categorical_transformer = Pipeline(\n",
+        "    [\n",
+        "        (\"impute\", SimpleImputer(strategy=\"most_frequent\")),\n",
+        "        (\"ohe\", OneHotEncoder(handle_unknown=\"ignore\", sparse=False)),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "preprocessor = ColumnTransformer(\n",
+        "    transformers=[\n",
+        "        (\"num\", numeric_transformer, selector(dtype_exclude=\"category\")),\n",
+        "        (\"cat\", categorical_transformer, selector(dtype_include=\"category\")),\n",
+        "    ]\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now, the preprocessing pipeline is defined, we can run it on our training data, and apply the generated transform to our test data:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "X_train = preprocessor.fit_transform(X_train)\n",
+        "X_test = preprocessor.transform(X_test)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -208,7 +256,7 @@
       "source": [
         "lr_predictor = LogisticRegression(solver='liblinear', fit_intercept=True)\n",
         "\n",
-        "lr_predictor.fit(X_train, Y_train)"
+        "lr_predictor.fit(X_train, y_train)"
       ]
     },
     {
@@ -226,7 +274,7 @@
       "source": [
         "svm_predictor = svm.SVC()\n",
         "\n",
-        "svm_predictor.fit(X_train, Y_train)"
+        "svm_predictor.fit(X_train, y_train)"
       ]
     },
     {
@@ -345,7 +393,7 @@
         "\n",
         "FairlearnDashboard(sensitive_features=A_test, \n",
         "                   sensitive_feature_names=['Sex', 'Race'],\n",
-        "                   y_true=Y_test.tolist(),\n",
+        "                   y_true=y_test.tolist(),\n",
         "                   y_pred=ys_pred)"
       ]
     },
@@ -375,7 +423,7 @@
         "\n",
         "from fairlearn.metrics._group_metric_set import _create_group_metric_set\n",
         "\n",
-        "dash_dict = _create_group_metric_set(y_true=Y_test,\n",
+        "dash_dict = _create_group_metric_set(y_true=y_test,\n",
         "                                     predictions=ys_pred,\n",
         "                                     sensitive_features=sf,\n",
         "                                     prediction_type='binary_classification')"

how-to-use-azureml/automated-machine-learning/automl_env.yml

@@ -2,9 +2,10 @@ name: azure_automl
 dependencies:
   # The python interpreter version.
   # Currently Azure ML only supports 3.5.2 and later.
-- pip<=19.3.1
-- python>=3.5.2,<3.6.8
+- pip==20.2.4
+- python>=3.5.2,<3.8
 - nb_conda
+- boto3==1.15.18
 - matplotlib==2.1.0
 - numpy==1.18.5
 - cython
@@ -20,9 +21,8 @@ dependencies:
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-widgets
+  - azureml-widgets~=1.24.0
   - pytorch-transformers==1.0.0
   - spacy==2.1.8
   - https://aka.ms/automl-resources/packages/en_core_web_sm-2.1.0.tar.gz
-  - -r https://automlcesdkdataresources.blob.core.windows.net/validated-requirements/1.17.0/validated_win32_requirements.txt [--no-deps]
-
+  - -r https://automlcesdkdataresources.blob.core.windows.net/validated-requirements/1.24.0/validated_win32_requirements.txt [--no-deps]

how-to-use-azureml/automated-machine-learning/automl_env_linux.yml

@@ -2,9 +2,10 @@ name: azure_automl
 dependencies:
   # The python interpreter version.
   # Currently Azure ML only supports 3.5.2 and later.
-- pip<=19.3.1
-- python>=3.5.2,<3.6.8
+- pip==20.2.4
+- python>=3.5.2,<3.8
 - nb_conda
+- boto3==1.15.18
 - matplotlib==2.1.0
 - numpy==1.18.5
 - cython
@@ -20,9 +21,8 @@ dependencies:
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-widgets
+  - azureml-widgets~=1.24.0
   - pytorch-transformers==1.0.0
   - spacy==2.1.8
   - https://aka.ms/automl-resources/packages/en_core_web_sm-2.1.0.tar.gz
-  - -r https://automlcesdkdataresources.blob.core.windows.net/validated-requirements/1.17.0/validated_linux_requirements.txt [--no-deps]
-
+  - -r https://automlcesdkdataresources.blob.core.windows.net/validated-requirements/1.24.0/validated_linux_requirements.txt [--no-deps]

how-to-use-azureml/automated-machine-learning/automl_env_mac.yml

@@ -2,10 +2,11 @@ name: azure_automl
 dependencies:
   # The python interpreter version.
   # Currently Azure ML only supports 3.5.2 and later.
-- pip<=19.3.1
+- pip==20.2.4
 - nomkl
-- python>=3.5.2,<3.6.8
+- python>=3.5.2,<3.8
 - nb_conda
+- boto3==1.15.18
 - matplotlib==2.1.0
 - numpy==1.18.5
 - cython
@@ -21,8 +22,8 @@ dependencies:
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-widgets
+  - azureml-widgets~=1.24.0
   - pytorch-transformers==1.0.0
   - spacy==2.1.8
-  - https://aka.ms/automl-resources/packages/en_core_web_sm-2.1.0.tar.gz  
-  - -r https://automlcesdkdataresources.blob.core.windows.net/validated-requirements/1.17.0/validated_darwin_requirements.txt [--no-deps]
+  - https://aka.ms/automl-resources/packages/en_core_web_sm-2.1.0.tar.gz
+  - -r https://automlcesdkdataresources.blob.core.windows.net/validated-requirements/1.24.0/validated_darwin_requirements.txt [--no-deps]

how-to-use-azureml/automated-machine-learning/classification-bank-marketing-all-features/auto-ml-classification-bank-marketing-all-features.ipynb

@@ -105,7 +105,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -167,7 +167,7 @@
         "You will need to create a compute target for your AutoML run. In this tutorial, you create AmlCompute as your training compute resource.\n",
         "#### Creation of AmlCompute takes approximately 5 minutes. \n",
         "If the AmlCompute with that name is already in your workspace this code will skip the creation process.\n",
-        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read this article on the default limits and how to request more quota."
+        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read [this article](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota."
       ]
     },
     {
@@ -899,7 +899,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "anumamah"
+        "name": "ratanase"
       }
     ],
     "category": "tutorial",

how-to-use-azureml/automated-machine-learning/classification-credit-card-fraud/auto-ml-classification-credit-card-fraud.ipynb

@@ -93,7 +93,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -450,7 +450,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "tzvikei"
+        "name": "ratanase"
       }
     ],
     "category": "tutorial",

how-to-use-azureml/automated-machine-learning/classification-text-dnn/auto-ml-classification-text-dnn.ipynb

@@ -42,9 +42,8 @@
         "\n",
         "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
         "\n",
-        "An Enterprise workspace is required for this notebook. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade).\n",
-        "\n",
         "Notebook synopsis:\n",
+        "\n",
         "1. Creating an Experiment in an existing Workspace\n",
         "2. Configuration and remote run of AutoML for a text dataset (20 Newsgroups dataset from scikit-learn) for classification\n",
         "3. Registering the best model for future use\n",
@@ -97,7 +96,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -272,8 +271,6 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "This step requires an Enterprise workspace to gain access to this feature. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade).\n",
-        "\n",
         "This notebook uses the blocked_models parameter to exclude some models that can take a longer time to train on some text datasets. You can choose to remove models from the blocked_models list but you may need to increase the experiment_timeout_hours parameter value to get results."
       ]
     },
@@ -301,7 +298,7 @@
         "                             compute_target=compute_target,\n",
         "                             training_data=train_dataset,\n",
         "                             label_column_name=target_column_name,\n",
-        "                             blocked_models = ['LightGBM'],\n",
+        "                             blocked_models = ['LightGBM', 'XGBoostClassifier'],\n",
         "                             **automl_settings\n",
         "                            )"
       ]

how-to-use-azureml/automated-machine-learning/continuous-retraining/auto-ml-continuous-retraining.ipynb

@@ -32,13 +32,6 @@
         "8. [Test Retraining](#Test-Retraining)"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "An Enterprise workspace is required for this notebook. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page.](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -88,7 +81,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -150,7 +143,7 @@
         "You will need to create a compute target for your AutoML run. In this tutorial, you create AmlCompute as your training compute resource.\n",
         "#### Creation of AmlCompute takes approximately 5 minutes. \n",
         "If the AmlCompute with that name is already in your workspace this code will skip the creation process.\n",
-        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read this article on the default limits and how to request more quota."
+        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read [this article](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota."
       ]
     },
     {
@@ -550,7 +543,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "anshirga"
+        "name": "vivijay"
       }
     ],
     "kernelspec": {

how-to-use-azureml/automated-machine-learning/experimental/automl_setup_thin_client.cmd

@@ -5,7 +5,7 @@ set options=%3
 set PIP_NO_WARN_SCRIPT_LOCATION=0
 
 IF "%conda_env_name%"=="" SET conda_env_name="azure_automl_experimental"
-IF "%automl_env_file%"=="" SET automl_env_file="automl_env.yml"
+IF "%automl_env_file%"=="" SET automl_env_file="automl_thin_client_env.yml"
 
 IF NOT EXIST %automl_env_file% GOTO YmlMissing
 

how-to-use-azureml/automated-machine-learning/experimental/automl_setup_thin_client_linux.sh

@@ -12,7 +12,7 @@ fi
 
 if [ "$AUTOML_ENV_FILE" == "" ]
 then
-  AUTOML_ENV_FILE="automl_env.yml"
+  AUTOML_ENV_FILE="automl_thin_client_env.yml"
 fi
 
 if [ ! -f $AUTOML_ENV_FILE ]; then

how-to-use-azureml/automated-machine-learning/experimental/automl_setup_thin_client_mac.sh

@@ -12,7 +12,7 @@ fi
 
 if [ "$AUTOML_ENV_FILE" == "" ]
 then
-  AUTOML_ENV_FILE="automl_env.yml"
+  AUTOML_ENV_FILE="automl_thin_client_env_mac.yml"
 fi
 
 if [ ! -f $AUTOML_ENV_FILE ]; then

how-to-use-azureml/automated-machine-learning/experimental/automl_thin_client_env.yml

@@ -5,16 +5,14 @@ dependencies:
 - pip<=19.3.1
 - python>=3.5.2,<3.8
 - nb_conda
-- matplotlib==2.1.0
-- numpy~=1.18.0
 - cython
 - urllib3<1.24
-- scikit-learn==0.22.1
-- pandas==0.25.1
+- PyJWT < 2.0.0
+- numpy==1.18.5
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
   - azureml-defaults
   - azureml-sdk
   - azureml-widgets
-  - azureml-explain-model
+  - pandas

how-to-use-azureml/automated-machine-learning/experimental/automl_thin_client_env_mac.yml

@@ -6,16 +6,14 @@ dependencies:
 - nomkl
 - python>=3.5.2,<3.8
 - nb_conda
-- matplotlib==2.1.0
-- numpy~=1.18.0
 - cython
 - urllib3<1.24
-- scikit-learn==0.22.1
-- pandas==0.25.1
+- PyJWT < 2.0.0
+- numpy==1.18.5
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
   - azureml-defaults
   - azureml-sdk
   - azureml-widgets
-  - azureml-explain-model
+  - pandas

how-to-use-azureml/automated-machine-learning/experimental/regression-model-proxy/auto-ml-regression-model-proxy.ipynb

@@ -67,10 +67,8 @@
       "source": [
         "import logging\n",
         "\n",
-        "from matplotlib import pyplot as plt\n",
-        "import numpy as np\n",
-        "import pandas as pd\n",
-        " \n",
+        "import json\n",
+        "\n",
         "\n",
         "import azureml.core\n",
         "from azureml.core.experiment import Experiment\n",
@@ -92,7 +90,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -115,9 +113,7 @@
         "output['Resource Group'] = ws.resource_group\n",
         "output['Location'] = ws.location\n",
         "output['Run History Name'] = experiment_name\n",
-        "pd.set_option('display.max_colwidth', -1)\n",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
-        "outputDf.T"
+        "output"
       ]
     },
     {
@@ -138,7 +134,8 @@
         "from azureml.core.compute_target import ComputeTargetException\n",
         "\n",
         "# Choose a name for your CPU cluster\n",
-        "cpu_cluster_name = \"reg-cluster\"\n",
+        "# Try to ensure that the cluster name is unique across the notebooks\n",
+        "cpu_cluster_name = \"reg-model-proxy\"\n",
         "\n",
         "# Verify that cluster does not exist already\n",
         "try:\n",
@@ -272,34 +269,13 @@
         "## Results"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Widget for Monitoring Runs\n",
-        "\n",
-        "The widget will first report a \"loading\" status while running the first iteration. After completing the first iteration, an auto-updating graph and table will be shown. The widget will refresh once per minute, so you should see the graph update as child runs complete.\n",
-        "\n",
-        "**Note:** The widget displays a link at the bottom. Use this link to open a web interface to explore the individual run details."
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.widgets import RunDetails\n",
-        "RunDetails(remote_run).show() "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "remote_run.wait_for_completion()"
+        "remote_run.wait_for_completion(show_output=True)"
       ]
     },
     {
@@ -321,6 +297,24 @@
         "print(best_run)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Show hyperparameters\n",
+        "Show the model pipeline used for the best run with its hyperparameters."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "run_properties = json.loads(best_run.get_details()['properties']['pipeline_script'])\n",
+        "print(json.dumps(run_properties, indent = 1)) "
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -346,18 +340,12 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# preview the first 3 rows of the dataset\n",
-        "\n",
-        "test_data = test_data.to_pandas_dataframe()\n",
-        "y_test = test_data['ERP'].fillna(0)\n",
-        "test_data = test_data.drop('ERP', 1)\n",
-        "test_data = test_data.fillna(0)\n",
+        "y_test = test_data.keep_columns('ERP')\n",
+        "test_data = test_data.drop_columns('ERP')\n",
         "\n",
         "\n",
-        "train_data = train_data.to_pandas_dataframe()\n",
-        "y_train = train_data['ERP'].fillna(0)\n",
-        "train_data = train_data.drop('ERP', 1)\n",
-        "train_data = train_data.fillna(0)\n"
+        "y_train = train_data.keep_columns('ERP')\n",
+        "train_data = train_data.drop_columns('ERP')\n"
       ]
     },
     {
@@ -375,7 +363,16 @@
       "outputs": [],
       "source": [
         "from azureml.train.automl.model_proxy import ModelProxy\n",
-        "best_model_proxy = ModelProxy(best_run)"
+        "best_model_proxy = ModelProxy(best_run)\n",
+        "y_pred_train = best_model_proxy.predict(train_data)\n",
+        "y_pred_test = best_model_proxy.predict(test_data)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Exploring results"
       ]
     },
     {
@@ -384,60 +381,15 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "y_pred_train = best_model_proxy.predict(train_data).to_pandas_dataframe().values.flatten()\n",
+        "y_pred_train = y_pred_train.to_pandas_dataframe().values.flatten()\n",
+        "y_train = y_train.to_pandas_dataframe().values.flatten()\n",
         "y_residual_train = y_train - y_pred_train\n",
         "\n",
-        "y_pred_test = best_model_proxy.predict(test_data).to_pandas_dataframe().values.flatten()\n",
-        "y_residual_test = y_test - y_pred_test"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%matplotlib inline\n",
-        "from sklearn.metrics import mean_squared_error, r2_score\n",
-        "\n",
-        "# Set up a multi-plot chart.\n",
-        "f, (a0, a1) = plt.subplots(1, 2, gridspec_kw = {'width_ratios':[1, 1], 'wspace':0, 'hspace': 0})\n",
-        "f.suptitle('Regression Residual Values', fontsize = 18)\n",
-        "f.set_figheight(6)\n",
-        "f.set_figwidth(16)\n",
-        "\n",
-        "# Plot residual values of training set.\n",
-        "a0.axis([0, 360, -100, 100])\n",
-        "a0.plot(y_residual_train, 'bo', alpha = 0.5)\n",
-        "a0.plot([-10,360],[0,0], 'r-', lw = 3)\n",
-        "a0.text(16,170,'RMSE = {0:.2f}'.format(np.sqrt(mean_squared_error(y_train, y_pred_train))), fontsize = 12)\n",
-        "a0.text(16,140,'R2 score = {0:.2f}'.format(r2_score(y_train, y_pred_train)),fontsize = 12)\n",
-        "a0.set_xlabel('Training samples', fontsize = 12)\n",
-        "a0.set_ylabel('Residual Values', fontsize = 12)\n",
-        "\n",
-        "# Plot residual values of test set.\n",
-        "a1.axis([0, 90, -100, 100])\n",
-        "a1.plot(y_residual_test, 'bo', alpha = 0.5)\n",
-        "a1.plot([-10,360],[0,0], 'r-', lw = 3)\n",
-        "a1.text(5,170,'RMSE = {0:.2f}'.format(np.sqrt(mean_squared_error(y_test, y_pred_test))), fontsize = 12)\n",
-        "a1.text(5,140,'R2 score = {0:.2f}'.format(r2_score(y_test, y_pred_test)),fontsize = 12)\n",
-        "a1.set_xlabel('Test samples', fontsize = 12)\n",
-        "a1.set_yticklabels([])\n",
-        "\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%matplotlib inline\n",
-        "test_pred = plt.scatter(y_test, y_pred_test, color='')\n",
-        "test_test = plt.scatter(y_test, y_test, color='g')\n",
-        "plt.legend((test_pred, test_test), ('prediction', 'truth'), loc='upper left', fontsize=8)\n",
-        "plt.show()"
+        "y_pred_test = y_pred_test.to_pandas_dataframe().values.flatten()\n",
+        "y_test = y_test.to_pandas_dataframe().values.flatten()\n",
+        "y_residual_test = y_test - y_pred_test\n",
+        "print(y_residual_train)\n",
+        "print(y_residual_test)"
       ]
     },
     {
@@ -451,7 +403,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "rakellam"
+        "name": "sekrupa"
       }
     ],
     "categories": [

how-to-use-azureml/automated-machine-learning/forecasting-beer-remote/auto-ml-forecasting-beer-remote.ipynb

@@ -54,9 +54,8 @@
         "\n",
         "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
         "\n",
-        "An Enterprise workspace is required for this notebook. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page.](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade)\n",
-        "\n",
         "Notebook synopsis:\n",
+        "\n",
         "1. Creating an Experiment in an existing Workspace\n",
         "2. Configuration and remote run of AutoML for a time-series model exploring Regression learners, Arima, Prophet and DNNs\n",
         "4. Evaluating the fitted model using a rolling test "
@@ -114,7 +113,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -219,6 +218,8 @@
         "\n",
         "**Time series identifier columns** are identified by values of the columns listed `time_series_id_column_names`, for example \"store\" and \"item\" if your data has multiple time series of sales, one series for each combination of store and item sold.\n",
         "\n",
+        "**Forecast frequency (freq)** This optional parameter represents the period with which the forecast is desired, for example, daily, weekly, yearly, etc. Use this parameter for the correction of time series containing irregular data points or for padding of short time series. The frequency needs to be a pandas offset alias. Please refer to [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects) for more information.\n",
+        "\n",
         "This dataset has only one time series. Please see the [orange juice notebook](https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/automated-machine-learning/forecasting-orange-juice-sales) for an example of a multi-time series dataset."
       ]
     },
@@ -350,9 +351,7 @@
         "|**iteration_timeout_minutes**|Time limit in minutes for each iteration.|\n",
         "|**training_data**|Input dataset, containing both features and label column.|\n",
         "|**label_column_name**|The name of the label column.|\n",
-        "|**enable_dnn**|Enable Forecasting DNNs|\n",
-        "\n",
-        "This step requires an Enterprise workspace to gain access to this feature. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page.](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade)."
+        "|**enable_dnn**|Enable Forecasting DNNs|\n"
       ]
     },
     {
@@ -650,7 +649,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "omkarm"
+        "name": "jialiu"
       }
     ],
     "hide_code_all_hidden": false,

how-to-use-azureml/automated-machine-learning/forecasting-beer-remote/helper.py

@@ -3,11 +3,11 @@ from azureml.core import Environment
 from azureml.core.conda_dependencies import CondaDependencies
 from azureml.train.estimator import Estimator
 from azureml.core.run import Run
+from azureml.automl.core.shared import constants
 
 
 def split_fraction_by_grain(df, fraction, time_column_name,
                             grain_column_names=None):
-
     if not grain_column_names:
         df['tmp_grain_column'] = 'grain'
         grain_column_names = ['tmp_grain_column']
@@ -17,10 +17,10 @@ def split_fraction_by_grain(df, fraction, time_column_name,
                   .groupby(grain_column_names, group_keys=False))
 
     df_head = df_grouped.apply(lambda dfg: dfg.iloc[:-int(len(dfg) *
-                               fraction)] if fraction > 0 else dfg)
+                                                          fraction)] if fraction > 0 else dfg)
 
     df_tail = df_grouped.apply(lambda dfg: dfg.iloc[-int(len(dfg) *
-                               fraction):] if fraction > 0 else dfg[:0])
+                                                         fraction):] if fraction > 0 else dfg[:0])
 
     if 'tmp_grain_column' in grain_column_names:
         for df2 in (df, df_head, df_tail):
@@ -59,11 +59,13 @@ def get_result_df(remote_run):
                                      'primary_metric', 'Score'])
     goal_minimize = False
     for run in children:
-        if('run_algorithm' in run.properties and 'score' in run.properties):
+        if run.get_status().lower() == constants.RunState.COMPLETE_RUN \
+                and 'run_algorithm' in run.properties and 'score' in run.properties:
+            # We only count in the completed child runs.
             summary_df[run.id] = [run.id, run.properties['run_algorithm'],
                                   run.properties['primary_metric'],
                                   float(run.properties['score'])]
-            if('goal' in run.properties):
+            if ('goal' in run.properties):
                 goal_minimize = run.properties['goal'].split('_')[-1] == 'min'
 
     summary_df = summary_df.T.sort_values(
@@ -118,7 +120,6 @@ def run_multiple_inferences(summary_df, train_experiment, test_experiment,
                             compute_target, script_folder, test_dataset,
                             lookback_dataset, max_horizon, target_column_name,
                             time_column_name, freq):
-
     for run_name, run_summary in summary_df.iterrows():
         print(run_name)
         print(run_summary)

how-to-use-azureml/automated-machine-learning/forecasting-bike-share/auto-ml-forecasting-bike-share.ipynb

@@ -87,7 +87,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -131,7 +131,7 @@
         "You will need to create a [compute target](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-set-up-training-targets#amlcompute) for your AutoML run. In this tutorial, you create AmlCompute as your training compute resource.\n",
         "#### Creation of AmlCompute takes approximately 5 minutes. \n",
         "If the AmlCompute with that name is already in your workspace this code will skip the creation process.\n",
-        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read this article on the default limits and how to request more quota."
+        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read [this article](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota."
       ]
     },
     {
@@ -205,6 +205,10 @@
       "outputs": [],
       "source": [
         "dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'dataset/bike-no.csv')]).with_timestamp_columns(fine_grain_timestamp=time_column_name) \n",
+        "\n",
+        "# Drop the columns 'casual' and 'registered' as these columns are a breakdown of the total and therefore a leak.\n",
+        "dataset = dataset.drop_columns(columns=['casual', 'registered'])\n",
+        "\n",
         "dataset.take(5).to_pandas_dataframe().reset_index(drop=True)"
       ]
     },
@@ -251,7 +255,7 @@
         "|**forecast_horizon**|The forecast horizon is how many periods forward you would like to forecast. This integer horizon is in units of the timeseries frequency (e.g. daily, weekly).|\n",
         "|**country_or_region_for_holidays**|The country/region used to generate holiday features. These should be ISO 3166 two-letter country/region codes (i.e. 'US', 'GB').|\n",
         "|**target_lags**|The target_lags specifies how far back we will construct the lags of the target variable.|\n",
-        "|**drop_column_names**|Name(s) of columns to drop prior to modeling|"
+        "|**freq**|Forecast frequency. This optional parameter represents the period with which the forecast is desired, for example, daily, weekly, yearly, etc. Use this parameter for the correction of time series containing irregular data points or for padding of short time series. The frequency needs to be a pandas offset alias. Please refer to [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects) for more information."
       ]
     },
     {
@@ -314,8 +318,7 @@
         "    time_column_name=time_column_name,\n",
         "    forecast_horizon=forecast_horizon,\n",
         "    country_or_region_for_holidays='US', # set country_or_region will trigger holiday featurizer\n",
-        "    target_lags='auto', # use heuristic based lag setting    \n",
-        "    drop_column_names=['casual', 'registered'] # these columns are a breakdown of the total and therefore a leak\n",
+        "    target_lags='auto' # use heuristic based lag setting    \n",
         ")\n",
         "\n",
         "automl_config = AutoMLConfig(task='forecasting',                             \n",
@@ -548,6 +551,9 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
+        "For more details on what metrics are included and how they are calculated, please refer to [supported metrics](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml#regressionforecasting-metrics). You could also calculate residuals, like described [here](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml#residuals).\n",
+        "\n",
+        "\n",
         "Since we did a rolling evaluation on the test set, we can analyze the predictions by their forecast horizon relative to the rolling origin. The model was initially trained at a forecast horizon of 14, so each prediction from the model is associated with a horizon value from 1 to 14. The horizon values are in a column named, \"horizon_origin,\" in the prediction set. For example, we can calculate some of the error metrics grouped by the horizon:"
       ]
     },
@@ -594,7 +600,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "erwright"
+        "name": "jialiu"
       }
     ],
     "category": "tutorial",

how-to-use-azureml/automated-machine-learning/forecasting-bike-share/forecasting_script.py

@@ -1,22 +1,24 @@
 import argparse
-import azureml.train.automl
-from azureml.core import Run
+from azureml.core import Dataset, Run
 from sklearn.externals import joblib
 
-
 parser = argparse.ArgumentParser()
 parser.add_argument(
     '--target_column_name', type=str, dest='target_column_name',
     help='Target Column Name')
+parser.add_argument(
+    '--test_dataset', type=str, dest='test_dataset',
+    help='Test Dataset')
 
 args = parser.parse_args()
 target_column_name = args.target_column_name
+test_dataset_id = args.test_dataset
 
 run = Run.get_context()
-# get input dataset by name
-test_dataset = run.input_datasets['test_data']
+ws = run.experiment.workspace
 
-df = test_dataset.to_pandas_dataframe().reset_index(drop=True)
+# get the input dataset by id
+test_dataset = Dataset.get_by_id(ws, id=test_dataset_id)
 
 X_test_df = test_dataset.drop_columns(columns=[target_column_name]).to_pandas_dataframe().reset_index(drop=True)
 y_test_df = test_dataset.with_timestamp_columns(None).keep_columns(columns=[target_column_name]).to_pandas_dataframe()

how-to-use-azureml/automated-machine-learning/forecasting-bike-share/run_forecast.py

@@ -1,29 +1,32 @@
-from azureml.train.estimator import Estimator
+from azureml.core import ScriptRunConfig
 
 
-def run_rolling_forecast(test_experiment, compute_target, train_run, test_dataset,
-                         target_column_name, inference_folder='./forecast'):
+def run_rolling_forecast(test_experiment, compute_target, train_run,
+                         test_dataset, target_column_name,
+                         inference_folder='./forecast'):
     train_run.download_file('outputs/model.pkl',
                             inference_folder + '/model.pkl')
 
     inference_env = train_run.get_environment()
 
-    est = Estimator(source_directory=inference_folder,
-                    entry_script='forecasting_script.py',
-                    script_params={
-                        '--target_column_name': target_column_name
-                    },
-                    inputs=[test_dataset.as_named_input('test_data')],
-                    compute_target=compute_target,
-                    environment_definition=inference_env)
+    config = ScriptRunConfig(source_directory=inference_folder,
+                             script='forecasting_script.py',
+                             arguments=['--target_column_name',
+                                        target_column_name,
+                                        '--test_dataset',
+                                        test_dataset.as_named_input(test_dataset.name)],
+                             compute_target=compute_target,
+                             environment=inference_env)
 
-    run = test_experiment.submit(est,
-                                 tags={
-                                     'training_run_id': train_run.id,
-                                     'run_algorithm': train_run.properties['run_algorithm'],
-                                     'valid_score': train_run.properties['score'],
-                                     'primary_metric': train_run.properties['primary_metric']
-                                 })
+    run = test_experiment.submit(config,
+                                 tags={'training_run_id':
+                                       train_run.id,
+                                       'run_algorithm':
+                                       train_run.properties['run_algorithm'],
+                                       'valid_score':
+                                       train_run.properties['score'],
+                                       'primary_metric':
+                                       train_run.properties['primary_metric']})
 
     run.log("run_algorithm", run.tags['run_algorithm'])
     return run

how-to-use-azureml/automated-machine-learning/forecasting-energy-demand/auto-ml-forecasting-energy-demand.ipynb

@@ -97,7 +97,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -301,7 +301,8 @@
         "|Property|Description|\n",
         "|-|-|\n",
         "|**time_column_name**|The name of your time column.|\n",
-        "|**forecast_horizon**|The forecast horizon is how many periods forward you would like to forecast. This integer horizon is in units of the timeseries frequency (e.g. daily, weekly).|"
+        "|**forecast_horizon**|The forecast horizon is how many periods forward you would like to forecast. This integer horizon is in units of the timeseries frequency (e.g. daily, weekly).|\n",
+        "|**freq**|Forecast frequency. This optional parameter represents the period with which the forecast is desired, for example, daily, weekly, yearly, etc. Use this parameter for the correction of time series containing irregular data points or for padding of short time series. The frequency needs to be a pandas offset alias. Please refer to [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects) for more information."
       ]
     },
     {
@@ -497,7 +498,7 @@
       "metadata": {},
       "source": [
         "### Evaluate\n",
-        "To evaluate the accuracy of the forecast, we'll compare against the actual sales quantities for some select metrics, included the mean absolute percentage error (MAPE).\n",
+        "To evaluate the accuracy of the forecast, we'll compare against the actual sales quantities for some select metrics, included the mean absolute percentage error (MAPE). For more metrics that can be used for evaluation after training, please see [supported metrics](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml#regressionforecasting-metrics), and [how to calculate residuals](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml#residuals).\n",
         "\n",
         "It is a good practice to always align the output explicitly to the input, as the count and order of the rows may have changed during transformations that span multiple rows."
       ]
@@ -703,7 +704,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "erwright"
+        "name": "jialiu"
       }
     ],
     "categories": [

how-to-use-azureml/automated-machine-learning/forecasting-forecast-function/auto-ml-forecasting-function.ipynb

@@ -24,7 +24,7 @@
       "metadata": {},
       "source": [
         "## Introduction\n",
-        "This notebook demonstrates the full interface to the `forecast()` function. \n",
+        "This notebook demonstrates the full interface of the `forecast()` function. \n",
         "\n",
         "The best known and most frequent usage of `forecast` enables forecasting on test sets that immediately follows training data. \n",
         "\n",
@@ -94,7 +94,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -302,7 +302,8 @@
         "* Set early termination to True, so the iterations through the models will stop when no improvements in accuracy score will be made.\n",
         "* Set limitations on the length of experiment run to 15 minutes.\n",
         "* Finally, we set the task to be forecasting.\n",
-        "* We apply the lag lead operator to the target value i.e. we use the previous values as a predictor for the future ones."
+        "* We apply the lag lead operator to the target value i.e. we use the previous values as a predictor for the future ones.\n",
+        "* [Optional] Forecast frequency parameter (freq) represents the period with which the forecast is desired, for example, daily, weekly, yearly, etc. Use this parameter for the correction of time series containing irregular data points or for padding of short time series. The frequency needs to be a pandas offset alias. Please refer to [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects) for more information."
       ]
     },
     {
@@ -809,7 +810,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "erwright"
+        "name": "jialiu"
       }
     ],
     "category": "tutorial",

how-to-use-azureml/automated-machine-learning/forecasting-orange-juice-sales/auto-ml-forecasting-orange-juice-sales.ipynb

@@ -82,7 +82,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -126,7 +126,7 @@
         "You will need to create a [compute target](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-set-up-training-targets#amlcompute) for your AutoML run. In this tutorial, you create AmlCompute as your training compute resource.\n",
         "#### Creation of AmlCompute takes approximately 5 minutes. \n",
         "If the AmlCompute with that name is already in your workspace this code will skip the creation process.\n",
-        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read this article on the default limits and how to request more quota."
+        "As with other Azure services, there are limits on certain resources (e.g. AmlCompute) associated with the Azure Machine Learning service. Please read [this article](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota."
       ]
     },
     {
@@ -169,6 +169,10 @@
       "source": [
         "time_column_name = 'WeekStarting'\n",
         "data = pd.read_csv(\"dominicks_OJ.csv\", parse_dates=[time_column_name])\n",
+        "\n",
+        "# Drop the columns 'logQuantity' as it is a leaky feature.\n",
+        "data.drop('logQuantity', axis=1, inplace=True)\n",
+        "\n",
         "data.head()"
       ]
     },
@@ -325,12 +329,11 @@
       "source": [
         "## Customization\n",
         "\n",
-        "The featurization customization in forecasting is an advanced feature in AutoML which allows our customers to change the default forecasting featurization behaviors and column types through `FeaturizationConfig`. The supported scenarios include,\n",
+        "The featurization customization in forecasting is an advanced feature in AutoML which allows our customers to change the default forecasting featurization behaviors and column types through `FeaturizationConfig`. The supported scenarios include:\n",
+        "\n",
         "1. Column purposes update: Override feature type for the specified column. Currently supports DateTime, Categorical and Numeric. This customization can be used in the scenario that the type of the column cannot correctly reflect its purpose. Some numerical columns, for instance, can be treated as Categorical columns which need to be converted to categorical while some can be treated as epoch timestamp which need to be converted to datetime. To tell our SDK to correctly preprocess these columns, a configuration need to be add with the columns and their desired types.\n",
         "2. Transformer parameters update: Currently supports parameter change for Imputer only. User can customize imputation methods. The supported imputing methods for target column are constant and ffill (forward fill). The supported imputing methods for feature columns are mean, median, most frequent, constant and ffill (forward fill). This customization can be used for the scenario that our customers know which imputation methods fit best to the input data. For instance, some datasets use NaN to represent 0 which the correct behavior should impute all the missing value with 0. To achieve this behavior, these columns need to be configured as constant imputation with `fill_value` 0.\n",
-        "3. Drop columns: Columns to drop from being featurized. These usually are the columns which are leaky or the columns contain no useful data.\n",
-        "\n",
-        "This step requires an Enterprise workspace to gain access to this feature. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page.](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade)"
+        "3. Drop columns: Columns to drop from being featurized. These usually are the columns which are leaky or the columns contain no useful data."
       ]
     },
     {
@@ -344,7 +347,6 @@
       "outputs": [],
       "source": [
         "featurization_config = FeaturizationConfig()\n",
-        "featurization_config.drop_columns = ['logQuantity']  # 'logQuantity' is a leaky feature, so we remove it.\n",
         "# Force the CPWVOL5 feature to be numeric type.\n",
         "featurization_config.add_column_purpose('CPWVOL5', 'Numeric')\n",
         "# Fill missing values in the target column, Quantity, with zeros.\n",
@@ -367,7 +369,8 @@
         "|-|-|\n",
         "|**time_column_name**|The name of your time column.|\n",
         "|**forecast_horizon**|The forecast horizon is how many periods forward you would like to forecast. This integer horizon is in units of the timeseries frequency (e.g. daily, weekly).|\n",
-        "|**time_series_id_column_names**|The column names used to uniquely identify the time series in data that has multiple rows with the same timestamp. If the time series identifiers are not defined, the data set is assumed to be one time series.|"
+        "|**time_series_id_column_names**|The column names used to uniquely identify the time series in data that has multiple rows with the same timestamp. If the time series identifiers are not defined, the data set is assumed to be one time series.|\n",
+        "|**freq**|Forecast frequency. This optional parameter represents the period with which the forecast is desired, for example, daily, weekly, yearly, etc. Use this parameter for the correction of time series containing irregular data points or for padding of short time series. The frequency needs to be a pandas offset alias. Please refer to [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects) for more information."
       ]
     },
     {
@@ -383,7 +386,7 @@
         "The forecast horizon is given in units of the time-series frequency; for instance, the OJ series frequency is weekly, so a horizon of 20 means that a trained model will estimate sales up to 20 weeks beyond the latest date in the training data for each series. In this example, we set the forecast horizon to the number of samples per series in the test set (n_test_periods). Generally, the value of this parameter will be dictated by business needs. For example, a demand planning application that estimates the next month of sales should set the horizon according to suitable planning time-scales. Please see the [energy_demand notebook](https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/automated-machine-learning/forecasting-energy-demand) for more discussion of forecast horizon.\n",
         "\n",
         "We note here that AutoML can sweep over two types of time-series models:\n",
-        "* Models that are trained for each series such as ARIMA and Facebook's Prophet. Note that these models are only available for [Enterprise Edition Workspaces](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-manage-workspace#upgrade).\n",
+        "* Models that are trained for each series such as ARIMA and Facebook's Prophet.\n",
         "* Models trained across multiple time-series using a regression approach.\n",
         "\n",
         "In the first case, AutoML loops over all time-series in your dataset and trains one model (e.g. AutoArima or Prophet, as the case may be) for each series. This can result in long runtimes to train these models if there are a lot of series in the data. One way to mitigate this problem is to fit models for different series in parallel if you have multiple compute cores available. To enable this behavior, set the `max_cores_per_iteration` parameter in your AutoMLConfig as shown in the example in the next cell. \n",
@@ -572,7 +575,7 @@
       "source": [
         "# Evaluate\n",
         "\n",
-        "To evaluate the accuracy of the forecast, we'll compare against the actual sales quantities for some select metrics, included the mean absolute percentage error (MAPE). \n",
+        "To evaluate the accuracy of the forecast, we'll compare against the actual sales quantities for some select metrics, included the mean absolute percentage error (MAPE). For more metrics that can be used for evaluation after training, please see [supported metrics](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml#regressionforecasting-metrics), and [how to calculate residuals](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml#residuals).\n",
         "\n",
         "We'll add predictions and actuals into a single dataframe for convenience in calculating the metrics."
       ]
@@ -764,7 +767,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "erwright"
+        "name": "jialiu"
       }
     ],
     "category": "tutorial",

how-to-use-azureml/automated-machine-learning/local-run-classification-credit-card-fraud/auto-ml-classification-credit-card-fraud-local.ipynb

@@ -96,7 +96,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -359,7 +359,7 @@
         "Besides retrieving an existing model explanation for an AutoML model, you can also explain your AutoML model with different test data. The following steps will allow you to compute and visualize engineered feature importance based on your test data.\n",
         "\n",
         "### Run the explanation\n",
-        "#### Download engineered feature importance from artifact store\n",
+        "#### Download the engineered feature importance from artifact store\n",
         "You can use ExplanationClient to download the engineered feature explanations from the artifact store of the best_run. You can also use azure portal url to view the dash board visualization of the feature importance values of the engineered features."
       ]
     },
@@ -375,6 +375,25 @@
         "print(\"You can visualize the engineered explanations under the 'Explanations (preview)' tab in the AutoML run at:-\\n\" + best_run.get_portal_url())"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Download the raw feature importance from artifact store\n",
+        "You can use ExplanationClient to download the raw feature explanations from the artifact store of the best_run. You can also use azure portal url to view the dash board visualization of the feature importance values of the raw features."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "raw_explanations = client.download_model_explanation(raw=True)\n",
+        "print(raw_explanations.get_feature_importance_dict())\n",
+        "print(\"You can visualize the raw explanations under the 'Explanations (preview)' tab in the AutoML run at:-\\n\" + best_run.get_portal_url())"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -474,6 +493,29 @@
         "print(\"You can visualize the engineered explanations under the 'Explanations (preview)' tab in the AutoML run at:-\\n\" + automl_run.get_portal_url())"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Use Mimic Explainer for computing and visualizing raw feature importance\n",
+        "The explain() method in MimicWrapper can be called with the transformed test samples to get the feature importance for the original features in your data. You can also use azure portal url to view the dash board visualization of the feature importance values of the original/raw features."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Compute the raw explanations\n",
+        "raw_explanations = explainer.explain(['local', 'global'], get_raw=True,\n",
+        "                                     raw_feature_names=automl_explainer_setup_obj.raw_feature_names,\n",
+        "                                     eval_dataset=automl_explainer_setup_obj.X_test_transform,\n",
+        "                                     raw_eval_dataset=automl_explainer_setup_obj.X_test_raw)\n",
+        "print(raw_explanations.get_feature_importance_dict())\n",
+        "print(\"You can visualize the raw explanations under the 'Explanations (preview)' tab in the AutoML run at:-\\n\" + automl_run.get_portal_url())"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -589,10 +631,13 @@
         "    automl_explainer_setup_obj = automl_setup_model_explanations(automl_model,\n",
         "                                                                 X_test=data, task='classification')\n",
         "    # Retrieve model explanations for engineered explanations\n",
-        "    engineered_local_importance_values = scoring_explainer.explain(automl_explainer_setup_obj.X_test_transform)    \n",
+        "    engineered_local_importance_values = scoring_explainer.explain(automl_explainer_setup_obj.X_test_transform)\n",
+        "    # Retrieve model explanations for raw explanations\n",
+        "    raw_local_importance_values = scoring_explainer.explain(automl_explainer_setup_obj.X_test_transform, get_raw=True)\n",
         "    # You can return any data type as long as it is JSON-serializable\n",
         "    return {'predictions': predictions.tolist(),\n",
-        "            'engineered_local_importance_values': engineered_local_importance_values}\n"
+        "            'engineered_local_importance_values': engineered_local_importance_values,\n",
+        "            'raw_local_importance_values': raw_local_importance_values}\n"
       ]
     },
     {
@@ -725,7 +770,9 @@
         "# Print the predicted value\n",
         "print('predictions:\\n{}\\n'.format(output['predictions']))\n",
         "# Print the engineered feature importances for the predicted value\n",
-        "print('engineered_local_importance_values:\\n{}\\n'.format(output['engineered_local_importance_values']))"
+        "print('engineered_local_importance_values:\\n{}\\n'.format(output['engineered_local_importance_values']))\n",
+        "# Print the raw feature importances for the predicted value\n",
+        "print('raw_local_importance_values:\\n{}\\n'.format(output['raw_local_importance_values']))\n"
       ]
     },
     {
@@ -773,7 +820,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "anumamah"
+        "name": "ratanase"
       }
     ],
     "category": "tutorial",

how-to-use-azureml/automated-machine-learning/regression-explanation-featurization/auto-ml-regression-explanation-featurization.ipynb

@@ -42,8 +42,6 @@
         "\n",
         "If you are using an Azure Machine Learning Compute Instance, you are all set.  Otherwise, go through the [configuration](../../../configuration.ipynb)  notebook first if you haven't already to establish your connection to the AzureML Workspace. \n",
         "\n",
-        "An Enterprise workspace is required for this notebook. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page.](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade) \n",
-        "\n",
         "In this notebook you will learn how to:\n",
         "1. Create an `Experiment` in an existing `Workspace`.\n",
         "2. Instantiating AutoMLConfig with FeaturizationConfig for customization\n",
@@ -98,7 +96,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -223,9 +221,8 @@
       "source": [
         "## Customization\n",
         "\n",
-        "This step requires an Enterprise workspace to gain access to this feature. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page.](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade). \n",
-        "\n",
         "Supported customization includes:\n",
+        "\n",
         "1. Column purpose update: Override feature type for the specified column.\n",
         "2. Transformer parameter update: Update parameters for the specified transformer. Currently supports Imputer and HashOneHotEncoder.\n",
         "3. Drop columns: Columns to drop from being featurized.\n",
@@ -447,7 +444,6 @@
       "metadata": {},
       "source": [
         "## Explanations\n",
-        "This step requires an Enterprise workspace to gain access to this feature. To learn more about creating an Enterprise workspace or upgrading to an Enterprise workspace from the Azure portal, please visit our [Workspace page.](https://docs.microsoft.com/azure/machine-learning/service/concept-workspace#upgrade). \n",
         "This section will walk you through the workflow to compute model explanations for an AutoML model on your remote compute.\n",
         "\n",
         "### Retrieve any AutoML Model for explanations\n",
@@ -655,7 +651,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Operationailze\n",
+        "## Operationalize\n",
         "In this section we will show how you can operationalize an AutoML model and the explainer which was used to compute the explanations in the previous section.\n",
         "\n",
         "### Register the AutoML model and the scoring explainer\n",
@@ -905,7 +901,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "anumamah"
+        "name": "anshirga"
       }
     ],
     "categories": [

how-to-use-azureml/automated-machine-learning/regression-explanation-featurization/train_explainer.py

@@ -4,7 +4,7 @@ import os
 import joblib
 
 from interpret.ext.glassbox import LGBMExplainableModel
-from automl.client.core.common.constants import MODEL_PATH
+from azureml.automl.core.shared.constants import MODEL_PATH
 from azureml.core.experiment import Experiment
 from azureml.core.dataset import Dataset
 from azureml.core.run import Run
@@ -66,7 +66,8 @@ engineered_explanations = explainer.explain(['local', 'global'], tag='engineered
 # Compute the raw explanations
 raw_explanations = explainer.explain(['local', 'global'], get_raw=True, tag='raw explanations',
                                      raw_feature_names=automl_explainer_setup_obj.raw_feature_names,
-                                     eval_dataset=automl_explainer_setup_obj.X_test_transform)
+                                     eval_dataset=automl_explainer_setup_obj.X_test_transform,
+                                     raw_eval_dataset=automl_explainer_setup_obj.X_test_raw)
 
 print("Engineered and raw explanations computed successfully")
 

how-to-use-azureml/automated-machine-learning/regression/auto-ml-regression.ipynb

@@ -92,7 +92,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.17.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.24.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -375,18 +375,12 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# preview the first 3 rows of the dataset\n",
-        "\n",
-        "test_data = test_data.to_pandas_dataframe()\n",
-        "y_test = test_data['ERP'].fillna(0)\n",
-        "test_data = test_data.drop('ERP', 1)\n",
-        "test_data = test_data.fillna(0)\n",
+        "y_test = test_data.keep_columns('ERP').to_pandas_dataframe()\n",
+        "test_data = test_data.drop_columns('ERP').to_pandas_dataframe()\n",
         "\n",
         "\n",
-        "train_data = train_data.to_pandas_dataframe()\n",
-        "y_train = train_data['ERP'].fillna(0)\n",
-        "train_data = train_data.drop('ERP', 1)\n",
-        "train_data = train_data.fillna(0)\n"
+        "y_train = train_data.keep_columns('ERP').to_pandas_dataframe()\n",
+        "train_data = train_data.drop_columns('ERP').to_pandas_dataframe()\n"
       ]
     },
     {
@@ -396,10 +390,10 @@
       "outputs": [],
       "source": [
         "y_pred_train = fitted_model.predict(train_data)\n",
-        "y_residual_train = y_train - y_pred_train\n",
+        "y_residual_train = y_train.values - y_pred_train\n",
         "\n",
         "y_pred_test = fitted_model.predict(test_data)\n",
-        "y_residual_test = y_test - y_pred_test"
+        "y_residual_test = y_test.values - y_pred_test"
       ]
     },
     {
@@ -462,7 +456,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "rakellam"
+        "name": "ratanase"
       }
     ],
     "categories": [

how-to-use-azureml/azure-synapse/README.md

@@ -0,0 +1,84 @@
+Azure Synapse Analytics is a limitless analytics service that brings together data integration, enterprise data warehousing, and big data analytics. It gives you the freedom to query data on your terms, using either serverless or dedicated resources—at scale. Azure Synapse brings these worlds together with a unified experience to ingest, explore, prepare, manage, and serve data for immediate BI and machine learning needs. A core offering within Azure Synapse Analytics are serverless Apache Spark pools enhanced for big data workloads.  
+
+Synapse in Aml integration is for customers who want to use Apache Spark in Azure Synapse Analytics to prepare data at scale in Azure ML before training their ML model. This will allow customers to work on their end-to-end ML lifecycle including large-scale data preparation, model training and deployment within Azure ML workspace without having to use suboptimal tools for machine learning or switch between multiple tools for data preparation and model training. The ability to perform all ML tasks within Azure ML will reduce time required for customers to iterate on a machine learning project which typically includes multiple rounds of data preparation and training.
+
+In the public preview, the capabilities are provided:
+
+- Link Azure Synapse Analytics workspace to Azure Machine Learning workspace (via ARM, UI or SDK) 
+- Attach Apache Spark pools powered by Azure Synapse Analytics as Azure Machine Learning compute targets (via ARM, UI or SDK) 
+- Launch Apache Spark sessions in notebooks and perform interactive data exploration and preparation.  This interactive experience leverages Apache Spark magic and customers will have session-level Conda support to install packages. 
+- Productionize ML pipelines by leveraging Apache Spark pools to pre-process big data 
+
+# Using Synapse in Azure machine learning
+
+## Create synapse resources
+
+Follow up the documents to create Synapse workspace and resource-setup.sh is available for you to create the resources.
+
+- Create from [Portal](https://docs.microsoft.com/en-us/azure/synapse-analytics/quickstart-create-workspace)
+- Create from [Cli](https://docs.microsoft.com/en-us/azure/synapse-analytics/quickstart-create-workspace-cli)
+
+Follow up the documents to create Synapse spark pool
+
+- Create from [Portal](https://docs.microsoft.com/en-us/azure/synapse-analytics/quickstart-create-apache-spark-pool-portal)
+- Create from [Cli](https://docs.microsoft.com/en-us/cli/azure/ext/synapse/synapse/spark/pool?view=azure-cli-latest)
+
+## Link Synapse Workspace
+
+Make sure you are the owner of synapse workspace so that you can link synapse workspace into AML.
+You can run resource-setup.py to link the synapse workspace and attach compute
+
+```python
+from azureml.core import Workspace
+ws = Workspace.from_config()
+
+from azureml.core import LinkedService, SynapseWorkspaceLinkedServiceConfiguration
+synapse_link_config = SynapseWorkspaceLinkedServiceConfiguration(
+    subscription_id="<subscription id>",
+    resource_group="<resource group",
+    name="<synapse workspace name>"
+)
+
+linked_service = LinkedService.register(
+    workspace=ws,
+    name='<link name>',
+    linked_service_config=synapse_link_config)
+
+```
+
+## Attach synapse spark pool as AzureML compute
+
+```python
+
+from azureml.core.compute import SynapseCompute, ComputeTarget
+spark_pool_name = "<spark pool name>"
+attached_synapse_name = "<attached compute name>"
+
+attach_config = SynapseCompute.attach_configuration(
+        linked_service,
+        type="SynapseSpark",
+        pool_name=spark_pool_name)
+
+synapse_compute=ComputeTarget.attach(
+        workspace=ws,
+        name=attached_synapse_name,
+        attach_configuration=attach_config)
+
+synapse_compute.wait_for_completion()
+```
+
+## Set up permission
+
+Grant Spark admin role to system assigned identity of the linked service so that the user can submit experiment run or pipeline run from AML workspace to synapse spark pool.
+
+Grant Spark admin role to the specific user so that the user can start spark session to synapse spark pool.
+
+You can get the system assigned identity information by running
+
+```python
+print(linked_service.system_assigned_identity_principal_id)
+```
+
+- Launch synapse studio of the synapse workspace and grant linked service MSI "Synapse Apache Spark administrator" role.
+
+- In azure portal grant linked service MSI "Storage Blob Data Contributor" role of the primary adlsgen2 account of synapse workspace to use the library management feature.

how-to-use-azureml/deployment/deploy-to-local/register-model-deploy-local.ipynb

@@ -77,7 +77,7 @@
       "source": [
         "## Create trained model\n",
         "\n",
-        "For this example, we will train a small model on scikit-learn's [diabetes dataset](https://scikit-learn.org/stable/datasets/index.html#diabetes-dataset). "
+        "For this example, we will train a small model on scikit-learn's [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset). "
       ]
     },
     {
@@ -382,13 +382,111 @@
       "source": [
         "## Update Service\n",
         "\n",
-        "If you want to change your model(s), Conda dependencies, or deployment configuration, call `update()` to rebuild the Docker image.\n",
-        "\n",
-        "```python\n",
-        "local_service.update(models=[SomeOtherModelObject],\n",
+        "If you want to change your model(s), Conda dependencies or deployment configuration, call `update()` to rebuild the Docker image.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "local_service.update(models=[model],\n",
         "                     inference_config=inference_config,\n",
-        "                     deployment_config=local_config)\n",
-        "```"
+        "                     deployment_config=deployment_config)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Deploy model to AKS cluster based on the LocalWebservice's configuration."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# This is a one time setup for AKS Cluster. You can reuse this cluster for multiple deployments after it has been created. If you delete the cluster or the resource group that contains it, then you would have to recreate it.\n",
+        "from azureml.core.compute import AksCompute, ComputeTarget\n",
+        "from azureml.core.compute_target import ComputeTargetException\n",
+        "\n",
+        "# Choose a name for your AKS cluster\n",
+        "aks_name = 'my-aks-9' \n",
+        "\n",
+        "# Verify the cluster does not exist already\n",
+        "try:\n",
+        "    aks_target = ComputeTarget(workspace=ws, name=aks_name)\n",
+        "    print('Found existing cluster, use it.')\n",
+        "except ComputeTargetException:\n",
+        "    # Use the default configuration (can also provide parameters to customize)\n",
+        "    prov_config = AksCompute.provisioning_configuration()\n",
+        "\n",
+        "    # Create the cluster\n",
+        "    aks_target = ComputeTarget.create(workspace = ws, \n",
+        "                                      name = aks_name, \n",
+        "                                      provisioning_configuration = prov_config)\n",
+        "\n",
+        "if aks_target.get_status() != \"Succeeded\":\n",
+        "    aks_target.wait_for_completion(show_output=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.webservice import AksWebservice\n",
+        "# Set the web service configuration (using default here)\n",
+        "aks_config = AksWebservice.deploy_configuration()\n",
+        "\n",
+        "# # Enable token auth and disable (key) auth on the webservice\n",
+        "# aks_config = AksWebservice.deploy_configuration(token_auth_enabled=True, auth_enabled=False)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%time\n",
+        "aks_service_name ='aks-service-1'\n",
+        "\n",
+        "aks_service = local_service.deploy_to_cloud(name=aks_service_name,\n",
+        "                                            deployment_config=aks_config,\n",
+        "                                            deployment_target=aks_target)\n",
+        "\n",
+        "aks_service.wait_for_deployment(show_output = True)\n",
+        "print(aks_service.state)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Test aks service\n",
+        "\n",
+        "sample_input = json.dumps({\n",
+        "    'data': dataset_x[0:2].tolist()\n",
+        "})\n",
+        "\n",
+        "aks_service.run(sample_input)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Delete the service if not needed.\n",
+        "aks_service.delete()"
       ]
     },
     {

how-to-use-azureml/deployment/enable-app-insights-in-production-service/enable-app-insights-in-production-service.ipynb

@@ -276,21 +276,24 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.exceptions import ComputeTargetException\n",
+        "from azureml.core.compute import ComputeTarget, AksCompute\n",
+        "from azureml.core.compute_target import ComputeTargetException\n",
         "\n",
-        "aks_name = \"my-aks\"\n",
+        "aks_name = \"my-aks-insights\"\n",
         "\n",
+        "creating_compute = False\n",
         "try:\n",
         "    aks_target = ComputeTarget(ws, aks_name)\n",
-        "    print(\"Using existing AKS cluster {}.\".format(aks_name))\n",
+        "    print(\"Using existing AKS compute target {}.\".format(aks_name))\n",
         "except ComputeTargetException:\n",
-        "    print(\"Creating a new AKS cluster {}.\".format(aks_name))\n",
+        "    print(\"Creating a new AKS compute target {}.\".format(aks_name))\n",
         "\n",
         "    # Use the default configuration (can also provide parameters to customize).\n",
         "    prov_config = AksCompute.provisioning_configuration()\n",
         "    aks_target = ComputeTarget.create(workspace=ws,\n",
         "                                      name=aks_name,\n",
-        "                                      provisioning_configuration=prov_config)"
+        "                                      provisioning_configuration=prov_config)\n",
+        "    creating_compute = True"
       ]
     },
     {
@@ -300,7 +303,7 @@
       "outputs": [],
       "source": [
         "%%time\n",
-        "if aks_target.provisioning_state != \"Succeeded\":\n",
+        "if creating_compute and aks_target.provisioning_state != \"Succeeded\":\n",
         "    aks_target.wait_for_completion(show_output=True)"
       ]
     },
@@ -380,7 +383,7 @@
         "    aks_service.wait_for_deployment(show_output=True)\n",
         "    print(aks_service.state)\n",
         "else:\n",
-        "    raise ValueError(\"AKS provisioning failed. Error: \", aks_service.error)"
+        "    raise ValueError(\"AKS cluster provisioning failed. Error: \", aks_target.provisioning_errors)"
       ]
     },
     {
@@ -458,7 +461,9 @@
         "%%time\n",
         "aks_service.delete()\n",
         "aci_service.delete()\n",
-        "model.delete()"
+        "model.delete()\n",
+        "if creating_compute:\n",
+        "    aks_target.delete()"
       ]
     }
   ],

how-to-use-azureml/deployment/onnx/mnist.py

@@ -94,6 +94,17 @@ def main():
     os.makedirs(output_dir, exist_ok=True)
 
     kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
+    # Use Azure Open Datasets for MNIST dataset
+    datasets.MNIST.resources = [
+        ("https://azureopendatastorage.azurefd.net/mnist/train-images-idx3-ubyte.gz",
+         "f68b3c2dcbeaaa9fbdd348bbdeb94873"),
+        ("https://azureopendatastorage.azurefd.net/mnist/train-labels-idx1-ubyte.gz",
+         "d53e105ee54ea40749a09fcbcd1e9432"),
+        ("https://azureopendatastorage.azurefd.net/mnist/t10k-images-idx3-ubyte.gz",
+         "9fb629c4189551a2d022fa330f9573f3"),
+        ("https://azureopendatastorage.azurefd.net/mnist/t10k-labels-idx1-ubyte.gz",
+         "ec29112dd5afa0611ce80d1b7f02629c")
+    ]
     train_loader = torch.utils.data.DataLoader(
         datasets.MNIST('data', train=True, download=True,
                        transform=transforms.Compose([transforms.ToTensor(),

how-to-use-azureml/deployment/onnx/onnx-inference-facial-expression-recognition-deploy.ipynb

@@ -70,16 +70,16 @@
         "\n",
         "import urllib.request\n",
         "\n",
-        "onnx_model_url = \"https://www.cntk.ai/OnnxModels/emotion_ferplus/opset_7/emotion_ferplus.tar.gz\"\n",
+        "onnx_model_url = \"https://github.com/onnx/models/blob/master/vision/body_analysis/emotion_ferplus/model/emotion-ferplus-7.tar.gz?raw=true\"\n",
         "\n",
-        "urllib.request.urlretrieve(onnx_model_url, filename=\"emotion_ferplus.tar.gz\")\n",
+        "urllib.request.urlretrieve(onnx_model_url, filename=\"emotion-ferplus-7.tar.gz\")\n",
         "\n",
         "# the ! magic command tells our jupyter notebook kernel to run the following line of \n",
         "# code from the command line instead of the notebook kernel\n",
         "\n",
         "# We use tar and xvcf to unzip the files we just retrieved from the ONNX model zoo\n",
         "\n",
-        "!tar xvzf emotion_ferplus.tar.gz"
+        "!tar xvzf emotion-ferplus-7.tar.gz"
       ]
     },
     {
@@ -570,7 +570,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "plt.figure(figsize = (16, 6), frameon=False)\n",
+        "plt.figure(figsize = (16, 6))\n",
         "plt.subplot(1, 8, 1)\n",
         "\n",
         "plt.text(x = 0, y = -30, s = \"True Label: \", fontsize = 13, color = 'black')\n",

how-to-use-azureml/deployment/onnx/onnx-inference-mnist-deploy.ipynb

@@ -70,9 +70,9 @@
         "\n",
         "import urllib.request\n",
         "\n",
-        "onnx_model_url = \"https://www.cntk.ai/OnnxModels/mnist/opset_7/mnist.tar.gz\"\n",
+        "onnx_model_url = \"https://github.com/onnx/models/blob/master/vision/classification/mnist/model/mnist-7.tar.gz?raw=true\"\n",
         "\n",
-        "urllib.request.urlretrieve(onnx_model_url, filename=\"mnist.tar.gz\")"
+        "urllib.request.urlretrieve(onnx_model_url, filename=\"mnist-7.tar.gz\")"
       ]
     },
     {
@@ -86,7 +86,7 @@
         "\n",
         "# We use tar and xvcf to unzip the files we just retrieved from the ONNX model zoo\n",
         "\n",
-        "!tar xvzf mnist.tar.gz"
+        "!tar xvzf mnist-7.tar.gz"
       ]
     },
     {
@@ -521,7 +521,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "plt.figure(figsize = (16, 6), frameon=False)\n",
+        "plt.figure(figsize = (16, 6))\n",
         "plt.subplot(1, 8, 1)\n",
         "\n",
         "plt.text(x = 0, y = -30, s = \"True Label: \", fontsize = 13, color = 'black')\n",
@@ -684,18 +684,7 @@
         "\n",
         "A convolution layer is a set of filters. Each filter is defined by a weight (**W**) matrix, and  bias ($b$).\n",
         "\n",
-        "![](https://www.cntk.ai/jup/cntk103d_filterset_v2.png)\n",
-        "\n",
-        "These filters are scanned across the image performing the dot product between the weights and corresponding input value ($x$). The bias value is added to the output of the dot product and the resulting sum is optionally mapped through an activation function. This process is illustrated in the following animation."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "Image(url=\"https://www.cntk.ai/jup/cntk103d_conv2d_final.gif\", width= 200)"
+        "These filters are scanned across the image performing the dot product between the weights and corresponding input value ($x$). The bias value is added to the output of the dot product and the resulting sum is optionally mapped through an activation function."
       ]
     },
     {
@@ -707,24 +696,6 @@
         "The MNIST model from the ONNX Model Zoo uses maxpooling to update the weights in its convolutions, summarized by the graphic below. You can see the entire workflow of our pre-trained model in the following image, with our input images and our output probabilities of each of our 10 labels. If you're interested in exploring the logic behind creating a Deep Learning model further, please look at the [training tutorial for our ONNX MNIST Convolutional Neural Network](https://github.com/Microsoft/CNTK/blob/master/Tutorials/CNTK_103D_MNIST_ConvolutionalNeuralNetwork.ipynb). "
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Max-Pooling for Convolutional Neural Nets\n",
-        "\n",
-        "![](http://www.cntk.ai/jup/c103d_max_pooling.gif)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Pre-Trained Model Architecture\n",
-        "\n",
-        "![](http://www.cntk.ai/jup/conv103d_mnist-conv-mp.png)"
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,

how-to-use-azureml/deployment/production-deploy-to-aks/production-deploy-to-aks-ssl.ipynb

@@ -226,7 +226,7 @@
         "# Leaf domain label generates a name using the formula\n",
         "#  \"<leaf-domain-label>######.<azure-region>.cloudapp.azure.net\"\n",
         "#  where \"######\" is a random series of characters\n",
-        "provisioning_config.enable_ssl(leaf_domain_label = \"contoso\")\n",
+        "provisioning_config.enable_ssl(leaf_domain_label = \"contoso\", overwrite_existing_domain = True)\n",
         "\n",
         "aks_name = 'my-aks-ssl-1' \n",
         "# Create the cluster\n",

how-to-use-azureml/explain-model/azure-integration/remote-explanation/explain-model-on-amlcompute.ipynb

@@ -23,7 +23,7 @@
         "# Train and explain models remotely via Azure Machine Learning Compute\n",
         "\n",
         "\n",
-        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to train and explain a regression model remotely on an Azure Machine Leanrning Compute Target (AMLCompute).**_\n",
+        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to train and explain a regression model remotely on an Azure Machine Learning Compute Target (AMLCompute).**_\n",
         "\n",
         "\n",
         "\n",
@@ -35,10 +35,7 @@
         "    1. Initialize a Workspace\n",
         "    1. Create an Experiment\n",
         "    1. Introduction to AmlCompute\n",
-        "    1. Submit an AmlCompute run in a few different ways\n",
-        "        1. Option 1: Provision as a run based compute target \n",
-        "        1. Option 2: Provision as a persistent compute target (Basic)\n",
-        "        1. Option 3: Provision as a persistent compute target (Advanced)\n",
+        "    1. Submit an AmlCompute run\n",
         "1. Additional operations to perform on AmlCompute\n",
         "1. [Download model explanations from Azure Machine Learning Run History](#Download)\n",
         "1. [Visualize explanations](#Visualize)\n",
@@ -158,7 +155,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Submit an AmlCompute run in a few different ways\n",
+        "## Submit an AmlCompute run\n",
         "\n",
         "First lets check which VM families are available in your region. Azure is a regional service and some specialized SKUs (especially GPUs) are only available in certain regions. Since AmlCompute is created in the region of your workspace, we will use the supported_vms () function to see if the VM family we want to use ('STANDARD_D2_V2') is supported.\n",
         "\n",
@@ -204,7 +201,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Option 1: Provision a compute target (Basic)\n",
+        "### Provision a compute target\n",
         "\n",
         "You can provision an AmlCompute resource by simply defining two parameters thanks to smart defaults. By default it autoscales from 0 nodes and provisions dedicated VMs to run your job in a container. This is useful when you want to continously re-use the same target, debug it between jobs or simply share the resource with other users of your workspace.\n",
         "\n",
@@ -262,7 +259,7 @@
         "run_config.environment.docker.enabled = True\n",
         "\n",
         "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-interpret', 'azureml-telemetry', 'azureml-interpret'\n",
+        "    'azureml-defaults', 'azureml-telemetry', 'azureml-interpret'\n",
         "]\n",
         "\n",
         "# Note: this is to pin the scikit-learn and pandas versions to be same as notebook.\n",
@@ -327,183 +324,6 @@
         "run.get_metrics()"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Option 2: Provision a compute target (Advanced)\n",
-        "\n",
-        "You can also specify additional properties or change defaults while provisioning AmlCompute using a more advanced configuration. This is useful when you want a dedicated cluster of 4 nodes (for example you can set the min_nodes and max_nodes to 4), or want the compute to be within an existing VNet in your subscription.\n",
-        "\n",
-        "In addition to `vm_size` and `max_nodes`, you can specify:\n",
-        "* `min_nodes`: Minimum nodes (default 0 nodes) to downscale to while running a job on AmlCompute\n",
-        "* `vm_priority`: Choose between 'dedicated' (default) and 'lowpriority' VMs when provisioning AmlCompute. Low Priority VMs use Azure's excess capacity and are thus cheaper but risk your run being pre-empted\n",
-        "* `idle_seconds_before_scaledown`: Idle time (default 120 seconds) to wait after run completion before auto-scaling to min_nodes\n",
-        "* `vnet_resourcegroup_name`: Resource group of the **existing** VNet within which AmlCompute should be provisioned\n",
-        "* `vnet_name`: Name of VNet\n",
-        "* `subnet_name`: Name of SubNet within the VNet"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.compute import ComputeTarget, AmlCompute\n",
-        "from azureml.core.compute_target import ComputeTargetException\n",
-        "\n",
-        "# Choose a name for your CPU cluster\n",
-        "cpu_cluster_name = \"cpu-cluster\"\n",
-        "\n",
-        "# Verify that cluster does not exist already\n",
-        "try:\n",
-        "    cpu_cluster = ComputeTarget(workspace=ws, name=cpu_cluster_name)\n",
-        "    print('Found existing cluster, use it.')\n",
-        "except ComputeTargetException:\n",
-        "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2',\n",
-        "                                                           vm_priority='lowpriority',\n",
-        "                                                           min_nodes=2,\n",
-        "                                                           max_nodes=4,\n",
-        "                                                           idle_seconds_before_scaledown='300',\n",
-        "                                                           vnet_resourcegroup_name='<my-resource-group>',\n",
-        "                                                           vnet_name='<my-vnet-name>',\n",
-        "                                                           subnet_name='<my-subnet-name>')\n",
-        "    cpu_cluster = ComputeTarget.create(ws, cpu_cluster_name, compute_config)\n",
-        "\n",
-        "cpu_cluster.wait_for_completion(show_output=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Configure & Run"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.runconfig import RunConfiguration\n",
-        "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "\n",
-        "# Create a new RunConfig object\n",
-        "run_config = RunConfiguration(framework=\"python\")\n",
-        "\n",
-        "# Set compute target to AmlCompute target created in previous step\n",
-        "run_config.target = cpu_cluster.name\n",
-        "\n",
-        "# Enable Docker \n",
-        "run_config.environment.docker.enabled = True\n",
-        "\n",
-        "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-interpret', 'azureml-telemetry', 'azureml-interpret'\n",
-        "]\n",
-        "\n",
-        "\n",
-        "\n",
-        "# Note: this is to pin the scikit-learn and pandas versions to be same as notebook.\n",
-        "# In production scenario user would choose their dependencies\n",
-        "import pkg_resources\n",
-        "available_packages = pkg_resources.working_set\n",
-        "sklearn_ver = None\n",
-        "pandas_ver = None\n",
-        "for dist in available_packages:\n",
-        "    if dist.key == 'scikit-learn':\n",
-        "        sklearn_ver = dist.version\n",
-        "    elif dist.key == 'pandas':\n",
-        "        pandas_ver = dist.version\n",
-        "sklearn_dep = 'scikit-learn'\n",
-        "pandas_dep = 'pandas'\n",
-        "if sklearn_ver:\n",
-        "    sklearn_dep = 'scikit-learn=={}'.format(sklearn_ver)\n",
-        "if pandas_ver:\n",
-        "    pandas_dep = 'pandas=={}'.format(pandas_ver)\n",
-        "# Specify CondaDependencies obj\n",
-        "# The CondaDependencies specifies the conda and pip packages that are installed in the environment\n",
-        "# the submitted job is run in.  Note the remote environment(s) needs to be similar to the local\n",
-        "# environment, otherwise if a model is trained or deployed in a different environment this can\n",
-        "# cause errors.  Please take extra care when specifying your dependencies in a production environment.\n",
-        "azureml_pip_packages.extend([sklearn_dep, pandas_dep])\n",
-        "run_config.environment.python.conda_dependencies = CondaDependencies.create(pip_packages=azureml_pip_packages)\n",
-        "\n",
-        "from azureml.core import Run\n",
-        "from azureml.core import ScriptRunConfig\n",
-        "\n",
-        "src = ScriptRunConfig(source_directory=project_folder, \n",
-        "                      script='train_explain.py', \n",
-        "                      run_config=run_config) \n",
-        "run = experiment.submit(config=src)\n",
-        "run"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%time\n",
-        "# Shows output of the run on stdout.\n",
-        "run.wait_for_completion(show_output=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "run.get_metrics()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Additional operations to perform on AmlCompute\n",
-        "\n",
-        "You can perform more operations on AmlCompute such as updating the node counts or deleting the compute. "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Get_status () gets the latest status of the AmlCompute target\n",
-        "cpu_cluster.get_status().serialize()\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Update () takes in the min_nodes, max_nodes and idle_seconds_before_scaledown and updates the AmlCompute target\n",
-        "# cpu_cluster.update(min_nodes=1)\n",
-        "# cpu_cluster.update(max_nodes=10)\n",
-        "cpu_cluster.update(idle_seconds_before_scaledown=300)\n",
-        "# cpu_cluster.update(min_nodes=2, max_nodes=4, idle_seconds_before_scaledown=600)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Delete () is used to deprovision and delete the AmlCompute target. Useful if you want to re-use the compute name \n",
-        "# 'cpu-cluster' in this case but use a different VM family for instance.\n",
-        "\n",
-        "# cpu_cluster.delete()"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

how-to-use-azureml/explain-model/azure-integration/remote-explanation/explain-model-on-amlcompute.yml

@@ -3,9 +3,11 @@ dependencies:
 - pip:
   - azureml-sdk
   - azureml-interpret
-  - interpret-community[visualization]
+  - flask
+  - flask-cors
+  - gevent>=1.3.6
+  - jinja2
+  - ipython
   - matplotlib
-  - azureml-contrib-interpret
-  - sklearn-pandas<2.0.0
   - azureml-dataset-runtime
   - ipywidgets

how-to-use-azureml/explain-model/azure-integration/run-history/save-retrieve-explanations-run-history.ipynb

@@ -57,7 +57,7 @@
         "Problem: IBM employee attrition classification with scikit-learn (run model explainer locally and upload explanation to the Azure Machine Learning Run History)\n",
         "\n",
         "1. Train a SVM classification model using Scikit-learn\n",
-        "2. Run 'explain_model' with AML Run History, which leverages run history service to store and manage the explanation data\n",
+        "2. Run 'explain-model-sample' with AML Run History, which leverages run history service to store and manage the explanation data\n",
         "---\n",
         "\n",
         "Setup: If you are using Jupyter notebooks, the extensions should be installed automatically with the package.\n",
@@ -226,36 +226,6 @@
         "                      ('classifier', SVC(C=1.0, probability=True))])"
       ]
     },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "'''\n",
-        "# Uncomment below if sklearn-pandas is not installed\n",
-        "#!pip install sklearn-pandas\n",
-        "from sklearn_pandas import DataFrameMapper\n",
-        "\n",
-        "# Impute, standardize the numeric features and one-hot encode the categorical features.    \n",
-        "\n",
-        "\n",
-        "numeric_transformations = [([f], Pipeline(steps=[('imputer', SimpleImputer(strategy='median')), ('scaler', StandardScaler())])) for f in numerical]\n",
-        "\n",
-        "categorical_transformations = [([f], OneHotEncoder(handle_unknown='ignore', sparse=False)) for f in categorical]\n",
-        "\n",
-        "transformations = numeric_transformations + categorical_transformations\n",
-        "\n",
-        "# Append classifier to preprocessing pipeline.\n",
-        "# Now we have a full prediction pipeline.\n",
-        "clf = Pipeline(steps=[('preprocessor', transformations),\n",
-        "                      ('classifier', SVC(C=1.0, probability=True))]) \n",
-        "\n",
-        "\n",
-        "\n",
-        "'''"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -475,7 +445,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "experiment_name = 'explain_model'\n",
+        "experiment_name = 'explain-model-sample'\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "run = experiment.start_logging()\n",
         "client = ExplanationClient.from_run(run)"

how-to-use-azureml/explain-model/azure-integration/run-history/save-retrieve-explanations-run-history.yml

@@ -3,7 +3,10 @@ dependencies:
 - pip:
   - azureml-sdk
   - azureml-interpret
-  - interpret-community[visualization]
+  - flask
+  - flask-cors
+  - gevent>=1.3.6
+  - jinja2
+  - ipython
   - matplotlib
-  - azureml-contrib-interpret
   - ipywidgets

how-to-use-azureml/explain-model/azure-integration/scoring-time/train-explain-model-locally-and-deploy.ipynb

@@ -166,12 +166,12 @@
       "source": [
         "from sklearn.model_selection import train_test_split\n",
         "import joblib\n",
+        "from sklearn.compose import ColumnTransformer\n",
         "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
         "from sklearn.impute import SimpleImputer\n",
         "from sklearn.pipeline import Pipeline\n",
         "from sklearn.linear_model import LogisticRegression\n",
         "from sklearn.ensemble import RandomForestClassifier\n",
-        "from sklearn_pandas import DataFrameMapper\n",
         "\n",
         "from interpret.ext.blackbox import TabularExplainer\n",
         "\n",
@@ -201,17 +201,23 @@
         "# Store the numerical columns in a list numerical\n",
         "numerical = attritionXData.columns.difference(categorical)\n",
         "\n",
-        "numeric_transformations = [([f], Pipeline(steps=[\n",
+        "# We create the preprocessing pipelines for both numeric and categorical data.\n",
+        "numeric_transformer = Pipeline(steps=[\n",
         "    ('imputer', SimpleImputer(strategy='median')),\n",
-        "    ('scaler', StandardScaler())])) for f in numerical]\n",
+        "    ('scaler', StandardScaler())])\n",
         "\n",
-        "categorical_transformations = [([f], OneHotEncoder(handle_unknown='ignore', sparse=False)) for f in categorical]\n",
+        "categorical_transformer = Pipeline(steps=[\n",
+        "    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),\n",
+        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))])\n",
         "\n",
-        "transformations = numeric_transformations + categorical_transformations\n",
+        "transformations = ColumnTransformer(\n",
+        "    transformers=[\n",
+        "        ('num', numeric_transformer, numerical),\n",
+        "        ('cat', categorical_transformer, categorical)])\n",
         "\n",
         "# Append classifier to preprocessing pipeline.\n",
         "# Now we have a full prediction pipeline.\n",
-        "clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),\n",
+        "clf = Pipeline(steps=[('preprocessor', transformations),\n",
         "                      ('classifier', RandomForestClassifier())])\n",
         "\n",
         "# Split data into train and test\n",
@@ -323,7 +329,7 @@
         "\n",
         "# azureml-defaults is required to host the model as a web service.\n",
         "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-interpret', 'azureml-core', 'azureml-telemetry',\n",
+        "    'azureml-defaults', 'azureml-core', 'azureml-telemetry',\n",
         "    'azureml-interpret'\n",
         "]\n",
         " \n",
@@ -350,7 +356,7 @@
         "# the submitted job is run in.  Note the remote environment(s) needs to be similar to the local\n",
         "# environment, otherwise if a model is trained or deployed in a different environment this can\n",
         "# cause errors.  Please take extra care when specifying your dependencies in a production environment.\n",
-        "myenv = CondaDependencies.create(pip_packages=['sklearn-pandas', 'pyyaml', sklearn_dep, pandas_dep] + azureml_pip_packages,\n",
+        "myenv = CondaDependencies.create(pip_packages=['pyyaml', sklearn_dep, pandas_dep] + azureml_pip_packages,\n",
         "                                 pin_sdk_version=False)\n",
         "\n",
         "with open(\"myenv.yml\",\"w\") as f:\n",

how-to-use-azureml/explain-model/azure-integration/scoring-time/train-explain-model-locally-and-deploy.yml

@@ -3,8 +3,10 @@ dependencies:
 - pip:
   - azureml-sdk
   - azureml-interpret
-  - interpret-community[visualization]
+  - flask
+  - flask-cors
+  - gevent>=1.3.6
+  - jinja2
+  - ipython
   - matplotlib
-  - azureml-contrib-interpret
-  - sklearn-pandas<2.0.0
   - ipywidgets

how-to-use-azureml/explain-model/azure-integration/scoring-time/train-explain-model-on-amlcompute-and-deploy.ipynb

@@ -267,7 +267,7 @@
         "run_config.environment.python.user_managed_dependencies = False\n",
         "\n",
         "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-interpret', 'azureml-telemetry', 'azureml-interpret'\n",
+        "    'azureml-defaults', 'azureml-telemetry', 'azureml-interpret'\n",
         "]\n",
         " \n",
         "\n",
@@ -294,7 +294,7 @@
         "# the submitted job is run in.  Note the remote environment(s) needs to be similar to the local\n",
         "# environment, otherwise if a model is trained or deployed in a different environment this can\n",
         "# cause errors.  Please take extra care when specifying your dependencies in a production environment.\n",
-        "azureml_pip_packages.extend(['sklearn-pandas', 'pyyaml', sklearn_dep, pandas_dep])\n",
+        "azureml_pip_packages.extend(['pyyaml', sklearn_dep, pandas_dep])\n",
         "run_config.environment.python.conda_dependencies = CondaDependencies.create(pip_packages=azureml_pip_packages)\n",
         "# Now submit a run on AmlCompute\n",
         "from azureml.core.script_run_config import ScriptRunConfig\n",
@@ -431,7 +431,7 @@
         "\n",
         "# WARNING: to install this, g++ needs to be available on the Docker image and is not by default (look at the next cell)\n",
         "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-interpret', 'azureml-core', 'azureml-telemetry',\n",
+        "    'azureml-defaults', 'azureml-core', 'azureml-telemetry',\n",
         "    'azureml-interpret'\n",
         "]\n",
         " \n",
@@ -458,7 +458,7 @@
         "# the submitted job is run in.  Note the remote environment(s) needs to be similar to the local\n",
         "# environment, otherwise if a model is trained or deployed in a different environment this can\n",
         "# cause errors.  Please take extra care when specifying your dependencies in a production environment.\n",
-        "azureml_pip_packages.extend(['sklearn-pandas', 'pyyaml', sklearn_dep, pandas_dep])\n",
+        "azureml_pip_packages.extend(['pyyaml', sklearn_dep, pandas_dep])\n",
         "myenv = CondaDependencies.create(pip_packages=azureml_pip_packages)\n",
         "\n",
         "with open(\"myenv.yml\",\"w\") as f:\n",

how-to-use-azureml/explain-model/azure-integration/scoring-time/train-explain-model-on-amlcompute-and-deploy.yml

@@ -3,10 +3,12 @@ dependencies:
 - pip:
   - azureml-sdk
   - azureml-interpret
-  - interpret-community[visualization]
+  - flask
+  - flask-cors
+  - gevent>=1.3.6
+  - jinja2
+  - ipython
   - matplotlib
-  - azureml-contrib-interpret
-  - sklearn-pandas<2.0.0
   - azureml-dataset-runtime
   - azureml-core
   - ipywidgets

how-to-use-azureml/explain-model/azure-integration/scoring-time/train_explain.py

@@ -5,13 +5,13 @@
 import os
 import pandas as pd
 import zipfile
-from sklearn.model_selection import train_test_split
 import joblib
+from sklearn.compose import ColumnTransformer
+from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler, OneHotEncoder
 from sklearn.impute import SimpleImputer
 from sklearn.pipeline import Pipeline
 from sklearn.linear_model import LogisticRegression
-from sklearn_pandas import DataFrameMapper
 
 from azureml.core.run import Run
 from interpret.ext.blackbox import TabularExplainer
@@ -57,16 +57,22 @@ for col, value in attritionXData.iteritems():
 # store the numerical columns
 numerical = attritionXData.columns.difference(categorical)
 
-numeric_transformations = [([f], Pipeline(steps=[
+# We create the preprocessing pipelines for both numeric and categorical data.
+numeric_transformer = Pipeline(steps=[
     ('imputer', SimpleImputer(strategy='median')),
-    ('scaler', StandardScaler())])) for f in numerical]
+    ('scaler', StandardScaler())])
 
-categorical_transformations = [([f], OneHotEncoder(handle_unknown='ignore', sparse=False)) for f in categorical]
+categorical_transformer = Pipeline(steps=[
+    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
+    ('onehot', OneHotEncoder(handle_unknown='ignore'))])
 
-transformations = numeric_transformations + categorical_transformations
+transformations = ColumnTransformer(
+    transformers=[
+        ('num', numeric_transformer, numerical),
+        ('cat', categorical_transformer, categorical)])
 
 # append classifier to preprocessing pipeline
-clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),
+clf = Pipeline(steps=[('preprocessor', transformations),
                       ('classifier', LogisticRegression(solver='lbfgs'))])
 
 # get the run this was submitted from to interact with run history

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/README.md

@@ -9,7 +9,7 @@ These notebooks below are designed to go in sequence.
 4. [aml-pipelines-data-transfer.ipynb](https://aka.ms/pl-data-trans): This notebook shows how you transfer data between supported datastores.
 5. [aml-pipelines-use-databricks-as-compute-target.ipynb](https://aka.ms/pl-databricks): This notebooks shows how you can use Pipelines to send your compute payload to Azure Databricks.
 6. [aml-pipelines-use-adla-as-compute-target.ipynb](https://aka.ms/pl-adla): This notebook shows how you can use Azure Data Lake Analytics (ADLA) as a compute target.
-7. [aml-pipelines-how-to-use-estimatorstep.ipynb](https://aka.ms/pl-estimator): This notebook shows how to use the EstimatorStep.
+7. [aml-pipelines-with-commandstep.ipynb](aml-pipelines-with-commandstep.ipynb): This notebook shows how to use the CommandStep.
 8. [aml-pipelines-parameter-tuning-with-hyperdrive.ipynb](https://aka.ms/pl-hyperdrive): HyperDriveStep in Pipelines shows how you can do hyper parameter tuning using Pipelines.
 9. [aml-pipelines-how-to-use-azurebatch-to-run-a-windows-executable.ipynb](https://aka.ms/pl-azbatch): AzureBatchStep can be used to run your custom code in AzureBatch cluster.
 10. [aml-pipelines-setup-schedule-for-a-published-pipeline.ipynb](https://aka.ms/pl-schedule): Once you publish a Pipeline, you can schedule it to trigger based on an interval or on data change in a defined datastore.
@@ -19,5 +19,6 @@ These notebooks below are designed to go in sequence.
 14. [aml-pipelines-how-to-use-pipeline-drafts.ipynb](http://aka.ms/pl-pl-draft): This notebook shows how to use Pipeline Drafts. Pipeline Drafts are mutable pipelines which can be used to submit runs and create Published Pipelines.
 15. [aml-pipelines-hot-to-use-modulestep.ipynb](https://aka.ms/pl-modulestep): This notebook shows how to define Module, ModuleVersion and how to use them in an AML Pipeline using ModuleStep.
 16. [aml-pipelines-with-notebook-runner-step.ipynb](https://aka.ms/pl-nbrstep): This notebook shows how you can run another notebook as a step in Azure Machine Learning Pipeline.
+17. [aml-pipelines-with-commandstep-r.ipynb](aml-pipelines-with-commandstep-r.ipynb): This notebook shows how to use CommandStep to run R scripts.
 
  ![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/README.png)

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-data-transfer.ipynb

@@ -22,6 +22,8 @@
         "# Azure Machine Learning Pipeline with DataTransferStep\n",
         "This notebook is used to demonstrate the use of DataTransferStep in an Azure Machine Learning Pipeline.\n",
         "\n",
+        "> **Note:** In Azure Machine Learning, you can write output data directly to Azure Blob Storage, Azure Data Lake Storage Gen 1, Azure Data Lake Storage Gen 2, Azure FileShare without going through extra DataTransferStep. Learn how to use [OutputFileDatasetConfig](https://docs.microsoft.com/python/api/azureml-core/azureml.data.output_dataset_config.outputfiledatasetconfig?view=azure-ml-py) to achieve that with sample notebooks [here](https://aka.ms/pipeline-with-dataset).**\n",
+        "\n",
         "In certain cases, you will need to transfer data from one data location to another. For example, your data may be in Azure SQL Database and you may want to move it to Azure Data Lake storage. Or, your data is in an ADLS account and you want to make it available in the Blob storage. The built-in **DataTransferStep** class helps you transfer data in these situations.\n",
         "\n",
         "The below examples show how to move data between different storage types supported in Azure Machine Learning.\n",

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-how-to-use-azurebatch-to-run-a-windows-executable.ipynb

@@ -341,7 +341,7 @@
       "outputs": [],
       "source": [
         "pipeline = Pipeline(workspace=ws, steps=[step])\n",
-        "pipeline_run = Experiment(ws, 'azurebatch_experiment').submit(pipeline)"
+        "pipeline_run = Experiment(ws, 'azurebatch_sample').submit(pipeline)"
       ]
     },
     {

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-how-to-use-pipeline-drafts.ipynb

@@ -130,7 +130,7 @@
         "\n",
         "pipeline_draft = PipelineDraft.create(ws, name=\"TestPipelineDraft\",\n",
         "                                      description=\"draft description\",\n",
-        "                                      experiment_name=\"helloworld\",\n",
+        "                                      experiment_name=\"pipeline_draft_sample\",\n",
         "                                      pipeline=pipeline,\n",
         "                                      continue_on_step_failure=True,\n",
         "                                      tags={'dev': 'true'},\n",

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-parameter-tuning-with-hyperdrive.ipynb

@@ -121,12 +121,17 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "os.makedirs('./data/mnist', exist_ok=True)\n",
+        "data_folder = os.path.join(os.getcwd(), 'data/mnist')\n",
+        "os.makedirs(data_folder, exist_ok=True)\n",
         "\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz', filename = './data/mnist/train-images.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz', filename = './data/mnist/train-labels.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename = './data/mnist/test-images.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename = './data/mnist/test-labels.gz')"
+        "urllib.request.urlretrieve('https://azureopendatastorage.blob.core.windows.net/mnist/train-images-idx3-ubyte.gz',\n",
+        "                           filename=os.path.join(data_folder, 'train-images-idx3-ubyte.gz'))\n",
+        "urllib.request.urlretrieve('https://azureopendatastorage.blob.core.windows.net/mnist/train-labels-idx1-ubyte.gz',\n",
+        "                           filename=os.path.join(data_folder, 'train-labels-idx1-ubyte.gz'))\n",
+        "urllib.request.urlretrieve('https://azureopendatastorage.blob.core.windows.net/mnist/t10k-images-idx3-ubyte.gz',\n",
+        "                           filename=os.path.join(data_folder, 't10k-images-idx3-ubyte.gz'))\n",
+        "urllib.request.urlretrieve('https://azureopendatastorage.blob.core.windows.net/mnist/t10k-labels-idx1-ubyte.gz',\n",
+        "                           filename=os.path.join(data_folder, 't10k-labels-idx1-ubyte.gz'))"
       ]
     },
     {
@@ -146,11 +151,11 @@
         "from utils import load_data\n",
         "\n",
         "# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the neural network converge faster.\n",
-        "X_train = load_data('./data/mnist/train-images.gz', False) / 255.0\n",
-        "y_train = load_data('./data/mnist/train-labels.gz', True).reshape(-1)\n",
+        "X_train = load_data(os.path.join(data_folder, 'train-images-idx3-ubyte.gz'), False) / np.float32(255.0)\n",
+        "X_test = load_data(os.path.join(data_folder, 't10k-images-idx3-ubyte.gz'), False) / np.float32(255.0)\n",
+        "y_train = load_data(os.path.join(data_folder, 'train-labels-idx1-ubyte.gz'), True).reshape(-1)\n",
+        "y_test = load_data(os.path.join(data_folder, 't10k-labels-idx1-ubyte.gz'), True).reshape(-1)\n",
         "\n",
-        "X_test = load_data('./data/mnist/test-images.gz', False) / 255.0\n",
-        "y_test = load_data('./data/mnist/test-labels.gz', True).reshape(-1)\n",
         "\n",
         "count = 0\n",
         "sample_size = 30\n",
@@ -232,7 +237,7 @@
         "                                                               max_nodes=4)\n",
         "\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
-        "    compute_target.wait_for_completion(show_output=True, timeout_in_minutes=20)\n",
+        "compute_target.wait_for_completion(show_output=True, timeout_in_minutes=20)\n",
         "\n",
         "print(\"Azure Machine Learning Compute attached\")\n",
         "\n",
@@ -249,7 +254,7 @@
         "                                                           max_nodes=4)\n",
         "    cpu_cluster = ComputeTarget.create(ws, cpu_cluster_name, compute_config)\n",
         "    \n",
-        "    cpu_cluster.wait_for_completion(show_output=True)"
+        "cpu_cluster.wait_for_completion(show_output=True)"
       ]
     },
     {

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-publish-and-run-using-rest-endpoint.ipynb

@@ -41,14 +41,14 @@
       "source": [
         "import azureml.core\n",
         "from azureml.core import Workspace, Datastore, Experiment, Dataset\n",
+        "from azureml.data import OutputFileDatasetConfig\n",
         "from azureml.core.compute import AmlCompute\n",
         "from azureml.core.compute import ComputeTarget\n",
         "\n",
         "# Check core SDK version number\n",
         "print(\"SDK version:\", azureml.core.VERSION)\n",
         "\n",
-        "from azureml.data.data_reference import DataReference\n",
-        "from azureml.pipeline.core import Pipeline, PipelineData\n",
+        "from azureml.pipeline.core import Pipeline\n",
         "from azureml.pipeline.steps import PythonScriptStep\n",
         "from azureml.pipeline.core.graph import PipelineParameter\n",
         "\n",
@@ -140,9 +140,9 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Define intermediate data using PipelineData\n",
-        "processed_data1 = PipelineData(\"processed_data1\",datastore=def_blob_store)\n",
-        "print(\"PipelineData object created\")"
+        "# Define intermediate data using OutputFileDatasetConfig\n",
+        "processed_data1 = OutputFileDatasetConfig(name=\"processed_data1\")\n",
+        "print(\"Output dataset object created\")"
       ]
     },
     {
@@ -170,9 +170,7 @@
         "\n",
         "trainStep = PythonScriptStep(\n",
         "    script_name=\"train.py\", \n",
-        "        arguments=[\"--input_data\", blob_input_data, \"--output_train\", processed_data1],\n",
-        "    inputs=[blob_input_data],\n",
-        "    outputs=[processed_data1],\n",
+        "        arguments=[\"--input_data\", blob_input_data.as_mount(), \"--output_train\", processed_data1],\n",
         "    compute_target=aml_compute, \n",
         "    source_directory=source_directory\n",
         ")\n",
@@ -195,16 +193,14 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# extractStep to use the intermediate data produced by step4\n",
+        "# extractStep to use the intermediate data produced by trainStep\n",
         "# This step also produces an output processed_data2\n",
-        "processed_data2 = PipelineData(\"processed_data2\", datastore=def_blob_store)\n",
+        "processed_data2 = OutputFileDatasetConfig(name=\"processed_data2\")\n",
         "source_directory = \"publish_run_extract\"\n",
         "\n",
         "extractStep = PythonScriptStep(\n",
         "    script_name=\"extract.py\",\n",
-        "    arguments=[\"--input_extract\", processed_data1, \"--output_extract\", processed_data2],\n",
-        "    inputs=[processed_data1],\n",
-        "    outputs=[processed_data2],\n",
+        "    arguments=[\"--input_extract\", processed_data1.as_input(), \"--output_extract\", processed_data2],\n",
         "    compute_target=aml_compute, \n",
         "    source_directory=source_directory)\n",
         "print(\"extractStep created\")"
@@ -256,15 +252,17 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Now define step6 that takes two inputs (both intermediate data), and produce an output\n",
-        "processed_data3 = PipelineData(\"processed_data3\", datastore=def_blob_store)\n",
+        "# Now define compareStep that takes two inputs (both intermediate data), and produce an output\n",
+        "processed_data3 = OutputFileDatasetConfig(name=\"processed_data3\")\n",
+        "\n",
+        "# You can register the output as dataset after job completion\n",
+        "processed_data3 = processed_data3.register_on_complete(\"compare_result\")\n",
+        "\n",
         "source_directory = \"publish_run_compare\"\n",
         "\n",
         "compareStep = PythonScriptStep(\n",
         "    script_name=\"compare.py\",\n",
-        "    arguments=[\"--compare_data1\", processed_data1, \"--compare_data2\", processed_data2, \"--output_compare\", processed_data3, \"--pipeline_param\", pipeline_param],\n",
-        "    inputs=[processed_data1, processed_data2],\n",
-        "    outputs=[processed_data3],    \n",
+        "    arguments=[\"--compare_data1\", processed_data1.as_input(), \"--compare_data2\", processed_data2.as_input(), \"--output_compare\", processed_data3, \"--pipeline_param\", pipeline_param],  \n",
         "    compute_target=aml_compute, \n",
         "    source_directory=source_directory)\n",
         "print(\"compareStep created\")"
@@ -327,7 +325,7 @@
       "outputs": [],
       "source": [
         "# submit a pipeline run\n",
-        "pipeline_run1 = Experiment(ws, 'Pipeline_experiment').submit(pipeline1)\n",
+        "pipeline_run1 = Experiment(ws, 'Pipeline_experiment_sample').submit(pipeline1)\n",
         "# publish a pipeline from the submitted pipeline run\n",
         "published_pipeline2 = pipeline_run1.publish_pipeline(name=\"My_New_Pipeline2\", description=\"My Published Pipeline Description\", version=\"0.1\", continue_on_step_failure=True)\n",
         "published_pipeline2"

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-setup-schedule-for-a-published-pipeline.ipynb

@@ -19,8 +19,8 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# How to Setup a Schedule for a Published Pipeline\n",
-        "In this notebook, we will show you how you can run an already published pipeline on a schedule."
+        "# How to Setup a Schedule for a Published Pipeline or Pipeline Endpoint\n",
+        "In this notebook, we will show you how you can run an already published pipeline or a pipeline endpoint on a schedule."
       ]
     },
     {
@@ -159,6 +159,43 @@
         "print(\"Newly published pipeline id: {}\".format(published_pipeline1.id))"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "source": [
+        "### Create a Pipeline Endpoint\n",
+        "Alternatively, you can create a schedule to run a pipeline endpoint instead of a published pipeline. You will need this to create a schedule against a pipeline endpoint in the last section of this notebook. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "jupyter": {
+          "outputs_hidden": false,
+          "source_hidden": false
+        },
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import PipelineEndpoint\n",
+        "\n",
+        "pipeline_endpoint = PipelineEndpoint.publish(workspace=ws, name=\"ScheduledPipelineEndpoint\",\n",
+        "                                            pipeline=pipeline1, description=\"Publish pipeline endpoint for schedule test\")\n",
+        "pipeline_endpoint"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -196,14 +233,24 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Create a schedule for the pipeline using a recurrence\n",
+        "### Create a schedule for the published pipeline using a recurrence\n",
         "This schedule will run on a specified recurrence interval."
       ]
     },
     {
       "cell_type": "code",
       "execution_count": null,
-      "metadata": {},
+      "metadata": {
+        "jupyter": {
+          "outputs_hidden": false,
+          "source_hidden": false
+        },
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
       "outputs": [],
       "source": [
         "from azureml.pipeline.core.schedule import ScheduleRecurrence, Schedule\n",
@@ -212,7 +259,7 @@
         "\n",
         "schedule = Schedule.create(workspace=ws, name=\"My_Schedule\",\n",
         "                           pipeline_id=pub_pipeline_id, \n",
-        "                           experiment_name='Schedule_Run',\n",
+        "                           experiment_name='Schedule-run-sample',\n",
         "                           recurrence=recurrence,\n",
         "                           wait_for_provisioning=True,\n",
         "                           description=\"Schedule Run\")\n",
@@ -308,7 +355,11 @@
     {
       "cell_type": "code",
       "execution_count": null,
-      "metadata": {},
+      "metadata": {
+        "gather": {
+          "logged": 1606157800044
+        }
+      },
       "outputs": [],
       "source": [
         "# Set the wait_for_provisioning flag to False if you do not want to wait  \n",
@@ -394,7 +445,7 @@
         "\n",
         "schedule = Schedule.create(workspace=ws, name=\"My_Schedule\",\n",
         "                           pipeline_id=pub_pipeline_id, \n",
-        "                           experiment_name='Schedule_Run',\n",
+        "                           experiment_name='Schedule-run-sample',\n",
         "                           datastore=datastore,\n",
         "                           wait_for_provisioning=True,\n",
         "                           description=\"Schedule Run\")\n",
@@ -410,7 +461,11 @@
     {
       "cell_type": "code",
       "execution_count": null,
-      "metadata": {},
+      "metadata": {
+        "gather": {
+          "logged": 1606157862620
+        }
+      },
       "outputs": [],
       "source": [
         "# Set the wait_for_provisioning flag to False if you do not want to wait  \n",
@@ -419,14 +474,151 @@
         "schedule = Schedule.get(ws, schedule_id)\n",
         "print(\"Disabled schedule {}. New status is: {}\".format(schedule.id, schedule.status))"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "source": [
+        "### Create a schedule for a pipeline endpoint\n",
+        "Alternative to creating schedules for a published pipeline, you can also create schedules to run pipeline endpoints.\n",
+        "Retrieve the pipeline endpoint id to create a schedule. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1606157888851
+        },
+        "jupyter": {
+          "outputs_hidden": false,
+          "source_hidden": false
+        },
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "outputs": [],
+      "source": [
+        "pipeline_endpoint_by_name = PipelineEndpoint.get(workspace=ws, name=\"ScheduledPipelineEndpoint\")\n",
+        "published_pipeline_endpoint_id = pipeline_endpoint_by_name.id\n",
+        "\n",
+        "recurrence = ScheduleRecurrence(frequency=\"Day\", interval=2, hours=[22], minutes=[30]) # Runs every other day at 10:30pm\n",
+        "\n",
+        "schedule = Schedule.create_for_pipeline_endpoint(workspace=ws, name=\"My_Endpoint_Schedule\",\n",
+        "                                                 pipeline_endpoint_id=published_pipeline_endpoint_id,\n",
+        "                                                 experiment_name='Schedule-run-sample',\n",
+        "                                                 recurrence=recurrence, description=\"Schedule_Run\",\n",
+        "                                                 wait_for_provisioning=True)\n",
+        "\n",
+        "# You may want to make sure that the schedule is provisioned properly\n",
+        "# before making any further changes to the schedule\n",
+        "\n",
+        "print(\"Created schedule with id: {}\".format(schedule.id))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "source": [
+        "### Get all schedules for a given pipeline endpoint\n",
+        "Once you have the pipeline endpoint ID, then you can get all schedules for that pipeline endopint."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "jupyter": {
+          "outputs_hidden": false,
+          "source_hidden": false
+        },
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "outputs": [],
+      "source": [
+        "schedules_for_pipeline_endpoints = Schedule.\\\n",
+        "    get_schedules_for_pipeline_endpoint_id(ws,\n",
+        "                                           pipeline_endpoint_id=published_pipeline_endpoint_id)\n",
+        "print('Got all schedules for pipeline endpoint:', published_pipeline_endpoint_id, 'Count:',\n",
+        "      len(schedules_for_pipeline_endpoints))\n",
+        "\n",
+        "print('done')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "source": [
+        "### Disable the schedule created for running the pipeline endpont\n",
+        "Recall the best practice of disabling schedules when not in use.\n",
+        "The number of schedule triggers allowed per month per region per subscription is 100,000.\n",
+        "This is calculated using the project trigger counts for all active schedules."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "jupyter": {
+          "outputs_hidden": false,
+          "source_hidden": false
+        },
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "outputs": [],
+      "source": [
+        "fetched_schedule = Schedule.get(ws, schedule_id)\n",
+        "print(\"Using schedule with id: {}\".format(fetched_schedule.id))\n",
+        "\n",
+        "# Set the wait_for_provisioning flag to False if you do not want to wait  \n",
+        "# for the call to provision the schedule in the backend.\n",
+        "fetched_schedule.disable(wait_for_provisioning=True)\n",
+        "fetched_schedule = Schedule.get(ws, schedule_id)\n",
+        "print(\"Disabled schedule {}. New status is: {}\".format(fetched_schedule.id, fetched_schedule.status))"
+      ]
     }
   ],
   "metadata": {
     "authors": [
       {
-        "name": "sanpil"
+        "name": "shbijlan"
       }
     ],
+    "categories": [
+      "how-to-use-azureml",
+      "machine-learning-pipelines",
+      "intro-to-pipelines"
+    ],
     "category": "tutorial",
     "compute": [
       "AML Compute"
@@ -441,7 +633,7 @@
     "framework": [
       "Azure ML"
     ],
-    "friendly_name": "How to Setup a Schedule for a Published Pipeline",
+    "friendly_name": "How to Setup a Schedule for a Published Pipeline or Pipeline Endpoint",
     "kernelspec": {
       "display_name": "Python 3.6",
       "language": "python",
@@ -459,6 +651,9 @@
       "pygments_lexer": "ipython3",
       "version": "3.6.7"
     },
+    "nteract": {
+      "version": "nteract-front-end@1.0.0"
+    },
     "order_index": 10,
     "star_tag": [
       "featured"
@@ -466,7 +661,7 @@
     "tags": [
       "None"
     ],
-    "task": "Demonstrates the use of Schedules for Published Pipelines"
+    "task": "Demonstrates the use of Schedules for Published Pipelines and Pipeline endpoints"
   },
   "nbformat": 4,
   "nbformat_minor": 2

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-setup-versioned-pipeline-endpoints.ipynb

@@ -553,7 +553,7 @@
       "outputs": [],
       "source": [
         "from azureml.core import Experiment\n",
-        "pipeline_run = Experiment(ws, name=\"submit_from_endpoint\").submit(pipeline_endpoint_by_name, tags={'endpoint_tag': \"1\"}, pipeline_version=\"0\")"
+        "pipeline_run = Experiment(ws, name=\"submit_endpoint_sample\").submit(pipeline_endpoint_by_name, tags={'endpoint_tag': \"1\"}, pipeline_version=\"0\")"
       ]
     }
   ],

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-with-automated-machine-learning-step.ipynb

@@ -30,7 +30,7 @@
         "## Introduction\n",
         "In this example we showcase how you can use AzureML Dataset to load data for AutoML via AML Pipeline. \n",
         "\n",
-        "If you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, make sure you have executed the [configuration](https://aka.ms/pl-config) before running this notebook.\n",
+        "If you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, make sure you have executed the [configuration](https://aka.ms/pl-config) before running this notebook, please also take a look at the [Automated ML setup-using-a-local-conda-environment](https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/automated-machine-learning#setup-using-a-local-conda-environment) section to setup the environment.\n",
         "\n",
         "In this notebook you will learn how to:\n",
         "1. Create an `Experiment` in an existing `Workspace`.\n",
@@ -101,7 +101,7 @@
       "metadata": {},
       "source": [
         "## Create an Azure ML experiment\n",
-        "Let's create an experiment named \"automlstep-classification\" and a folder to hold the training scripts. The script runs will be recorded under the experiment in Azure.\n",
+        "Let's create an experiment named \"automlstep-sample\" and a folder to hold the training scripts. The script runs will be recorded under the experiment in Azure.\n",
         "\n",
         "The best practice is to use separate folders for scripts and its dependent files for each step and specify that folder as the `source_directory` for the step. This helps reduce the size of the snapshot created for the step (only the specific folder is snapshotted). Since changes in any files in the `source_directory` would trigger a re-upload of the snapshot, this helps keep the reuse of the step when there are no changes in the `source_directory` of the step."
       ]
@@ -113,7 +113,7 @@
       "outputs": [],
       "source": [
         "# Choose a name for the run history container in the workspace.\n",
-        "experiment_name = 'automlstep-classification'\n",
+        "experiment_name = 'automlstep-sample'\n",
         "project_folder = './project'\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-with-automated-machine-learning-step.yml

@@ -2,7 +2,3 @@ name: aml-pipelines-with-automated-machine-learning-step
 dependencies:
 - pip:
   - azureml-sdk
-  - azureml-train-automl
-  - azureml-widgets
-  - matplotlib
-  - pandas_ml

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-with-commandstep-r.ipynb

@@ -0,0 +1,343 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-how-to-use-estimatorstep.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# How to use CommandStep in Azure ML Pipelines\n",
+        "\n",
+        "This notebook shows how to use the CommandStep with Azure Machine Learning Pipelines for running R scripts in a pipeline.\n",
+        "\n",
+        "The example shows training a model in R to predict probability of fatality for vehicle crashes.\n",
+        "\n",
+        "\n",
+        "## Prerequisite:\n",
+        "* Understand the [architecture and terms](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture) introduced by Azure Machine Learning\n",
+        "* If you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, go through the [configuration notebook](https://aka.ms/pl-config) to:\n",
+        "    * install the Azure ML SDK\n",
+        "    * create a workspace and its configuration file (`config.json`)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Let's get started. First let's import some Python libraries."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "# check core SDK version number\n",
+        "print(\"Azure ML SDK Version: \", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Initialize workspace\n",
+        "Initialize a [Workspace](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#workspace) object from the existing workspace you created in the Prerequisites step. `Workspace.from_config()` creates a workspace object from the details stored in `config.json`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Workspace\n",
+        "ws = Workspace.from_config()\n",
+        "print('Workspace name: ' + ws.name, \n",
+        "      'Azure region: ' + ws.location, \n",
+        "      'Subscription id: ' + ws.subscription_id, \n",
+        "      'Resource group: ' + ws.resource_group, sep = '\\n')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create or Attach existing AmlCompute\n",
+        "You will need to create a [compute target](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#compute-target) for training your model. In this tutorial, you create `AmlCompute` as your training compute resource."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "If we could not find the cluster with the given name, then we will create a new cluster here. We will create an `AmlCompute` cluster of `STANDARD_D2_V2` CPU VMs. This process is broken down into 3 steps:\n",
+        "1. create the configuration (this step is local and only takes a second)\n",
+        "2. create the cluster (this step will take about **20 seconds**)\n",
+        "3. provision the VMs to bring the cluster to the initial size (of 1 in this case). This step will take about **3-5 minutes** and is providing only sparse output in the process. Please make sure to wait until the call returns before moving to the next cell"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.compute import ComputeTarget, AmlCompute\n",
+        "from azureml.core.compute_target import ComputeTargetException\n",
+        "\n",
+        "# choose a name for your cluster\n",
+        "cluster_name = \"cpu-cluster\"\n",
+        "\n",
+        "try:\n",
+        "    compute_target = ComputeTarget(workspace=ws, name=cluster_name)\n",
+        "    print('Found existing compute target')\n",
+        "except ComputeTargetException:\n",
+        "    print('Creating a new compute target...')\n",
+        "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2', max_nodes=4)\n",
+        "\n",
+        "    # create the cluster\n",
+        "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
+        "\n",
+        "    # can poll for a minimum number of nodes and for a specific timeout. \n",
+        "    # if no min node count is provided it uses the scale settings for the cluster\n",
+        "    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
+        "\n",
+        "# use get_status() to get a detailed status for the current cluster. \n",
+        "print(compute_target.get_status().serialize())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now that you have created the compute target, let's see what the workspace's `compute_targets` property returns. You should now see one entry named 'cpu-cluster' of type `AmlCompute`."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create a CommandStep\n",
+        "CommandStep adds a step to run a command in a Pipeline. For the full set of configurable options see the CommandStep [reference docs](https://docs.microsoft.com/python/api/azureml-pipeline-steps/azureml.pipeline.steps.commandstep?view=azure-ml-py).\n",
+        "\n",
+        "- **name:** Name of the step\n",
+        "- **runconfig:** ScriptRunConfig object. You can configure a ScriptRunConfig object as you would for a standalone non-pipeline run and pass it in to this parameter. If using this option, you do not have to specify the `command`, `source_directory`, `compute_target` parameters of the CommandStep constructor as they are already defined in your ScriptRunConfig.\n",
+        "- **runconfig_pipeline_params:** Override runconfig properties at runtime using key-value pairs each with name of the runconfig property and PipelineParameter for that property\n",
+        "- **command:** The command to run or path of the executable/script relative to `source_directory`. It is required unless the `runconfig` parameter is specified. It can be specified with string arguments in a single string or with input/output/PipelineParameter in a list.\n",
+        "- **source_directory:** A folder containing the script and other resources used in the step.\n",
+        "- **compute_target:** Compute target to use \n",
+        "- **allow_reuse:** Whether the step should reuse previous results when run with the same settings/inputs. If this is false, a new run will always be generated for this step during pipeline execution.\n",
+        "- **version:** Optional version tag to denote a change in functionality for the step\n",
+        "\n",
+        "> The best practice is to use separate folders for scripts and its dependent files for each step and specify that folder as the `source_directory` for the step. This helps reduce the size of the snapshot created for the step (only the specific folder is snapshotted). Since changes in any files in the `source_directory` would trigger a re-upload of the snapshot, this helps keep the reuse of the step when there are no changes in the `source_directory` of the step."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Configure environment\n",
+        "\n",
+        "Configure the environment for the train step. In this example we will create an environment from the Dockerfile we have included.\n",
+        "\n",
+        "> Azure ML currently requires Python as an implicit dependency, so Python must installed in your image even if your training script does not have this dependency."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Environment\n",
+        "import os\n",
+        "\n",
+        "src_dir = 'commandstep_r'\n",
+        "\n",
+        "env = Environment.from_dockerfile(name='r_env', dockerfile=os.path.join(src_dir, 'Dockerfile'))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Configure input training dataset\n",
+        "\n",
+        "This tutorial uses data from the US National Highway Traffic Safety Administration. This dataset includes data from over 25,000 car crashes in the US, with variables you can use to predict the likelihood of a fatality. We have included an Rdata file that includes the accidents data for analysis.\n",
+        "\n",
+        "Here we use the workspace's default datastore to upload the training data file (**accidents.Rd**); in practice you can use any datastore you want."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "datastore = ws.get_default_datastore()\n",
+        "data_ref = datastore.upload_files(files=[os.path.join(src_dir, 'accidents.Rd')], target_path='accidentdata')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now create a FileDataset from the data, which will be used as an input to the train step."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Dataset\n",
+        "dataset = Dataset.File.from_files(datastore.path('accidentdata'))\n",
+        "dataset"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now create a ScriptRunConfig that configures the training run. Note that in the `command` we include the input dataset for the training data.\n",
+        "\n",
+        "> For detailed guidance on how to move data in pipelines for input and output data, see the documentation [Moving data into and between ML pipelines](https://docs.microsoft.com/azure/machine-learning/how-to-move-data-in-out-of-pipelines)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import ScriptRunConfig\n",
+        "\n",
+        "train_config = ScriptRunConfig(source_directory=src_dir,\n",
+        "                            command=['Rscript accidents.R --data_folder', dataset.as_mount(), '--output_folder outputs'],\n",
+        "                            compute_target=compute_target,\n",
+        "                            environment=env)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now create a CommandStep and pass in the ScriptRunConfig object to the `runconfig` parameter."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.steps import CommandStep\n",
+        "\n",
+        "train = CommandStep(name='train', runconfig=train_config)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Build and Submit the Pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline\n",
+        "from azureml.core import Experiment\n",
+        "\n",
+        "pipeline = Pipeline(workspace=ws, steps=[train])\n",
+        "pipeline_run = Experiment(ws, 'r-commandstep-pipeline').submit(pipeline)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## View Run Details"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.widgets import RunDetails\n",
+        "RunDetails(pipeline_run).show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "minxia"
+      }
+    ],
+    "category": "tutorial",
+    "compute": [
+      "AML Compute"
+    ],
+    "datasets": [
+      "Custom"
+    ],
+    "deployment": [
+      "None"
+    ],
+    "exclude_from_index": false,
+    "framework": [
+      "Azure ML"
+    ],
+    "friendly_name": "Azure Machine Learning Pipeline with CommandStep for R",
+    "kernelspec": {
+      "display_name": "Python 3.6",
+      "language": "python",
+      "name": "python36"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.7.7"
+    },
+    "order_index": 7,
+    "star_tag": [
+      "None"
+    ],
+    "tags": [
+      "None"
+    ],
+    "task": "Demonstrates the use of CommandStep for running R scripts"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-with-commandstep-r.yml

@@ -1,4 +1,4 @@
-name: distributed-pytorch-with-nccl-gloo
+name: aml-pipelines-with-commandstep-r
 dependencies:
 - pip:
   - azureml-sdk

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-with-commandstep.ipynb

@@ -20,15 +20,15 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# How to use EstimatorStep in AML Pipeline\n",
+        "# How to use CommandStep in Azure ML Pipelines\n",
         "\n",
-        "This notebook shows how to use the EstimatorStep with Azure Machine Learning Pipelines. Estimator is a convenient object in Azure Machine Learning that wraps run configuration information to help simplify the tasks of specifying how a script is executed.\n",
+        "This notebook shows how to use the CommandStep with Azure Machine Learning Pipelines for running commands in steps. The example shows running distributed TensorFlow training from within a pipeline.\n",
         "\n",
         "\n",
         "## Prerequisite:\n",
         "* Understand the [architecture and terms](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture) introduced by Azure Machine Learning\n",
         "* If you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, go through the [configuration notebook](https://aka.ms/pl-config) to:\n",
-        "    * install the AML SDK\n",
+        "    * install the Azure ML SDK\n",
         "    * create a workspace and its configuration file (`config.json`)"
       ]
     },
@@ -100,75 +100,57 @@
         "from azureml.core.compute_target import ComputeTargetException\n",
         "\n",
         "# choose a name for your cluster\n",
-        "cluster_name = \"amlcomp\"\n",
+        "cluster_name = \"gpu-cluster\"\n",
         "\n",
         "try:\n",
-        "    cpu_cluster = ComputeTarget(workspace=ws, name=cluster_name)\n",
+        "    gpu_cluster = ComputeTarget(workspace=ws, name=cluster_name)\n",
         "    print('Found existing compute target')\n",
         "except ComputeTargetException:\n",
         "    print('Creating a new compute target...')\n",
         "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_NC6', max_nodes=4)\n",
         "\n",
         "    # create the cluster\n",
-        "    cpu_cluster = ComputeTarget.create(ws, cluster_name, compute_config)\n",
+        "    gpu_cluster = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
         "    # can poll for a minimum number of nodes and for a specific timeout. \n",
         "    # if no min node count is provided it uses the scale settings for the cluster\n",
-        "    cpu_cluster.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
+        "    gpu_cluster.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
-        "print(cpu_cluster.get_status().serialize())"
+        "print(gpu_cluster.get_status().serialize())"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Now that you have created the compute target, let's see what the workspace's `compute_targets` property returns. You should now see one entry named 'cpu-cluster' of type `AmlCompute`."
+        "Now that you have created the compute target, let's see what the workspace's `compute_targets` property returns. You should now see one entry named 'gpu-cluster' of type `AmlCompute`."
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Use a simple script\n",
-        "We have already created a simple \"hello world\" script. This is the script that we will submit through the estimator pattern. It prints a hello-world message, and if Azure ML SDK is installed, it will also logs an array of values ([Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number))."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Build an Estimator object\n",
-        "Estimator by default will attempt to use Docker-based execution. You can also enable Docker and let estimator pick the default CPU image supplied by Azure ML for execution. You can target an AmlCompute cluster (or any other supported compute target types). You can also customize the conda environment by adding conda and/or pip packages.\n",
+        "## Create a CommandStep\n",
+        "CommandStep adds a step to run a command in a Pipeline. For the full set of configurable options see the CommandStep [reference docs](https://docs.microsoft.com/python/api/azureml-pipeline-steps/azureml.pipeline.steps.commandstep?view=azure-ml-py).\n",
         "\n",
-        "> Note: The arguments to the entry script used in the Estimator object should be specified as *list* using\n",
-        "    'estimator_entry_script_arguments' parameter when instantiating EstimatorStep. Estimator object's parameter\n",
-        "    'script_params' accepts a dictionary. However 'estimator_entry_script_arguments' parameter expects arguments as\n",
-        "    a list.\n",
+        "- **name:** Name of the step\n",
+        "- **runconfig:** ScriptRunConfig object. You can configure a ScriptRunConfig object as you would for a standalone non-pipeline run and pass it in to this parameter. If using this option, you do not have to specify the `command`, `source_directory`, `compute_target` parameters of the CommandStep constructor as they are already defined in your ScriptRunConfig.\n",
+        "- **runconfig_pipeline_params:** Override runconfig properties at runtime using key-value pairs each with name of the runconfig property and PipelineParameter for that property\n",
+        "- **command:** The command to run or path of the executable/script relative to `source_directory`. It is required unless the `runconfig` parameter is specified. It can be specified with string arguments in a single string or with input/output/PipelineParameter in a list.\n",
+        "- **source_directory:** A folder containing the script and other resources used in the step.\n",
+        "- **compute_target:** Compute target to use \n",
+        "- **allow_reuse:** Whether the step should reuse previous results when run with the same settings/inputs. If this is false, a new run will always be generated for this step during pipeline execution.\n",
+        "- **version:** Optional version tag to denote a change in functionality for the step\n",
         "\n",
-        "> Estimator object initialization involves specifying a list of data input and output.\n",
-        "    In Pipelines, a step can take another step's output as input. So when creating an EstimatorStep.\n",
-        "   \n",
         "> The best practice is to use separate folders for scripts and its dependent files for each step and specify that folder as the `source_directory` for the step. This helps reduce the size of the snapshot created for the step (only the specific folder is snapshotted). Since changes in any files in the `source_directory` would trigger a re-upload of the snapshot, this helps keep the reuse of the step when there are no changes in the `source_directory` of the step."
       ]
     },
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "tags": [
-          "datareference-remarks-sample"
-        ]
-      },
-      "outputs": [],
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
-        "from azureml.core import Datastore\n",
-        "\n",
-        "def_blob_store = Datastore(ws, \"workspaceblobstore\")\n",
-        "\n",
-        "#upload input data to workspaceblobstore\n",
-        "def_blob_store.upload_files(files=['20news.pkl'], target_path='20newsgroups')"
+        "First define the environment that you want to step to run in. This example users a curated TensorFlow environment, but in practice you can configure any environment you want."
       ]
     },
     {
@@ -177,46 +159,46 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core import Dataset\n",
-        "from azureml.data import OutputFileDatasetConfig\n",
+        "from azureml.core import Environment\n",
         "\n",
-        "# create dataset to be used as the input to estimator step\n",
-        "input_data = Dataset.File.from_files(def_blob_store.path('20newsgroups/20news.pkl'))\n",
-        "\n",
-        "# OutputFileDatasetConfig by default write output to the default workspaceblobstore\n",
-        "output = OutputFileDatasetConfig()\n",
-        "\n",
-        "source_directory = 'estimator_train'"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.train.estimator import Estimator\n",
-        "\n",
-        "est = Estimator(source_directory=source_directory, \n",
-        "                compute_target=cpu_cluster, \n",
-        "                entry_script='dummy_train.py', \n",
-        "                conda_packages=['scikit-learn'])"
+        "tf_env = Environment.get(ws, name='AzureML-TensorFlow-2.3-GPU')"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Create an EstimatorStep\n",
-        "[EstimatorStep](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.estimator_step.estimatorstep?view=azure-ml-py) adds a step to run Estimator in a Pipeline.\n",
+        "This example will first create a ScriptRunConfig object that configures the training job. Since we are running a distributed job, specify the `distributed_job_config` parameter. If you are just running a single-node job, omit that parameter.\n",
         "\n",
-        "- **name:** Name of the step\n",
-        "- **estimator:** Estimator object\n",
-        "- **estimator_entry_script_arguments:** A list of command-line arguments\n",
-        "- **runconfig_pipeline_params:** Override runconfig properties at runtime using key-value pairs each with name of the runconfig property and PipelineParameter for that property\n",
-        "- **compute_target:** Compute target to use \n",
-        "- **allow_reuse:** Whether the step should reuse previous results when run with the same settings/inputs. If this is false, a new run will always be generated for this step during pipeline execution.\n",
-        "- **version:** Optional version tag to denote a change in functionality for the step"
+        "> If you have an input dataset you want to use in this step, you can specify that as part of the command. For example, if you have a FileDataset object called `dataset` and a `--data-dir` script argument, you can do the following: `command=['python train.py --epochs 30 --data-dir', dataset.as_mount()]`.\n",
+        "\n",
+        "> For detailed guidance on how to move data in pipelines for input and output data, see the documentation [Moving data into and between ML pipelines](https://docs.microsoft.com/azure/machine-learning/how-to-move-data-in-out-of-pipelines)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import ScriptRunConfig\n",
+        "from azureml.core.runconfig import MpiConfiguration\n",
+        "\n",
+        "src_dir = 'commandstep_train'\n",
+        "distr_config = MpiConfiguration(node_count=2) # you can also specify the process_count_per_node parameter for multi-process-per-node training\n",
+        "\n",
+        "src = ScriptRunConfig(source_directory=src_dir,\n",
+        "                      command=['python train.py --epochs 30'],\n",
+        "                      compute_target=gpu_cluster,\n",
+        "                      environment=tf_env,\n",
+        "                      distributed_job_config=distr_config)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now create a CommandStep and pass in the ScriptRunConfig object to the `runconfig` parameter."
       ]
     },
     {
@@ -229,20 +211,16 @@
       },
       "outputs": [],
       "source": [
-        "from azureml.pipeline.steps import EstimatorStep\n",
+        "from azureml.pipeline.steps import CommandStep\n",
         "\n",
-        "est_step = EstimatorStep(name=\"Estimator_Train\", \n",
-        "                         estimator=est, \n",
-        "                         estimator_entry_script_arguments=[\"--datadir\", input_data.as_mount(), \"--output\", output],\n",
-        "                         runconfig_pipeline_params=None, \n",
-        "                         compute_target=cpu_cluster)"
+        "train = CommandStep(name='train-mnist', runconfig=src)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Build and Submit the Experiment"
+        "## Build and Submit the Pipeline"
       ]
     },
     {
@@ -253,8 +231,9 @@
       "source": [
         "from azureml.pipeline.core import Pipeline\n",
         "from azureml.core import Experiment\n",
-        "pipeline = Pipeline(workspace=ws, steps=[est_step])\n",
-        "pipeline_run = Experiment(ws, 'Estimator_sample').submit(pipeline)"
+        "\n",
+        "pipeline = Pipeline(workspace=ws, steps=[train])\n",
+        "pipeline_run = Experiment(ws, 'train-commandstep-pipeline').submit(pipeline)"
       ]
     },
     {
@@ -295,7 +274,7 @@
     "framework": [
       "Azure ML"
     ],
-    "friendly_name": "Azure Machine Learning Pipeline with EstimatorStep",
+    "friendly_name": "Azure Machine Learning Pipeline with CommandStep",
     "kernelspec": {
       "display_name": "Python 3.6",
       "language": "python",
@@ -311,7 +290,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.6.7"
+      "version": "3.7.7"
     },
     "order_index": 7,
     "star_tag": [
@@ -320,7 +299,7 @@
     "tags": [
       "None"
     ],
-    "task": "Demonstrates the use of EstimatorStep"
+    "task": "Demonstrates the use of CommandStep"
   },
   "nbformat": 4,
   "nbformat_minor": 2

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-with-commandstep.yml

@@ -1,4 +1,4 @@
-name: aml-pipelines-how-to-use-estimatorstep
+name: aml-pipelines-with-commandstep
 dependencies:
 - pip:
   - azureml-sdk

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-with-data-dependency-steps.ipynb

@@ -428,7 +428,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "pipeline_run1 = Experiment(ws, 'Data_dependency').submit(pipeline1)\n",
+        "pipeline_run1 = Experiment(ws, 'Data_dependency_sample').submit(pipeline1)\n",
         "print(\"Pipeline is submitted for execution\")"
       ]
     },

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/commandstep_r/Dockerfile

@@ -0,0 +1,11 @@
+FROM rocker/tidyverse:4.0.0-ubuntu18.04
+ 
+# Install python
+RUN apt-get update -qq && \
+ apt-get install -y python3
+ 
+# Create link for python
+RUN ln -f /usr/bin/python3 /usr/bin/python
+
+# Install additional R packages
+RUN R -e "install.packages(c('optparse'), repos = 'https://cloud.r-project.org/')"

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/commandstep_r/accidents.R

@@ -0,0 +1,34 @@
+#' Copyright(c) Microsoft Corporation.
+#' Licensed under the MIT license.
+
+library(optparse)
+
+options <- list(
+  make_option(c("-d", "--data_folder")),
+  make_option(c("--output_folder"))
+  
+)
+
+opt_parser <- OptionParser(option_list = options)
+opt <- parse_args(opt_parser)
+
+paste(opt$data_folder)
+
+accidents <- readRDS(file.path(opt$data_folder, "accidents.Rd"))
+summary(accidents)
+
+mod <- glm(dead ~ dvcat + seatbelt + frontal + sex + ageOFocc + yearVeh + airbag  + occRole, family=binomial, data=accidents)
+summary(mod)
+predictions <- factor(ifelse(predict(mod)>0.1, "dead","alive"))
+accuracy <- mean(predictions == accidents$dead)
+
+# make directory for output dir
+output_dir = opt$output_folder
+if (!dir.exists(output_dir)){
+  dir.create(output_dir)
+}
+
+# save model
+model_path = file.path(output_dir, "model.rds")
+saveRDS(mod, file = model_path)
+message("Model saved")

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/commandstep_train/conda_dependencies.yml

@@ -0,0 +1,8 @@
+channels:
+  - conda-forge
+dependencies:
+  - python=3.7
+  - pip:
+    - azureml-defaults
+    - tensorflow-gpu==2.3.0
+    - horovod==0.19.5

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/commandstep_train/train.py

@@ -0,0 +1,120 @@
+# Copyright 2019 Uber Technologies, Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Script adapted from: https://github.com/horovod/horovod/blob/master/examples/tensorflow2_keras_mnist.py
+# ==============================================================================
+
+import tensorflow as tf
+import horovod.tensorflow.keras as hvd
+
+import os
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--learning-rate", "-lr", type=float, default=0.001)
+parser.add_argument("--epochs", type=int, default=24)
+parser.add_argument("--steps-per-epoch", type=int, default=500)
+args = parser.parse_args()
+
+# Horovod: initialize Horovod.
+hvd.init()
+
+# Horovod: pin GPU to be used to process local rank (one GPU per process)
+gpus = tf.config.experimental.list_physical_devices("GPU")
+for gpu in gpus:
+    tf.config.experimental.set_memory_growth(gpu, True)
+if gpus:
+    tf.config.experimental.set_visible_devices(gpus[hvd.local_rank()], "GPU")
+
+(mnist_images, mnist_labels), _ = tf.keras.datasets.mnist.load_data(
+    path="mnist-%d.npz" % hvd.rank()
+)
+
+dataset = tf.data.Dataset.from_tensor_slices(
+    (
+        tf.cast(mnist_images[..., tf.newaxis] / 255.0, tf.float32),
+        tf.cast(mnist_labels, tf.int64),
+    )
+)
+dataset = dataset.repeat().shuffle(10000).batch(128)
+
+mnist_model = tf.keras.Sequential(
+    [
+        tf.keras.layers.Conv2D(32, [3, 3], activation="relu"),
+        tf.keras.layers.Conv2D(64, [3, 3], activation="relu"),
+        tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
+        tf.keras.layers.Dropout(0.25),
+        tf.keras.layers.Flatten(),
+        tf.keras.layers.Dense(128, activation="relu"),
+        tf.keras.layers.Dropout(0.5),
+        tf.keras.layers.Dense(10, activation="softmax"),
+    ]
+)
+
+# Horovod: adjust learning rate based on number of GPUs.
+scaled_lr = args.learning_rate * hvd.size()
+opt = tf.optimizers.Adam(scaled_lr)
+
+# Horovod: add Horovod DistributedOptimizer.
+opt = hvd.DistributedOptimizer(opt)
+
+# Horovod: Specify `experimental_run_tf_function=False` to ensure TensorFlow
+# uses hvd.DistributedOptimizer() to compute gradients.
+mnist_model.compile(
+    loss=tf.losses.SparseCategoricalCrossentropy(),
+    optimizer=opt,
+    metrics=["accuracy"],
+    experimental_run_tf_function=False,
+)
+
+callbacks = [
+    # Horovod: broadcast initial variable states from rank 0 to all other processes.
+    # This is necessary to ensure consistent initialization of all workers when
+    # training is started with random weights or restored from a checkpoint.
+    hvd.callbacks.BroadcastGlobalVariablesCallback(0),
+    # Horovod: average metrics among workers at the end of every epoch.
+    #
+    # Note: This callback must be in the list before the ReduceLROnPlateau,
+    # TensorBoard or other metrics-based callbacks.
+    hvd.callbacks.MetricAverageCallback(),
+    # Horovod: using `lr = 1.0 * hvd.size()` from the very beginning leads to worse final
+    # accuracy. Scale the learning rate `lr = 1.0` ---> `lr = 1.0 * hvd.size()` during
+    # the first three epochs. See https://arxiv.org/abs/1706.02677 for details.
+    hvd.callbacks.LearningRateWarmupCallback(
+        warmup_epochs=3, initial_lr=scaled_lr, verbose=1
+    ),
+]
+
+# Horovod: save checkpoints only on worker 0 to prevent other workers from corrupting them.
+if hvd.rank() == 0:
+    output_dir = "./outputs"
+    os.makedirs(output_dir, exist_ok=True)
+    callbacks.append(
+        tf.keras.callbacks.ModelCheckpoint(
+            os.path.join(output_dir, "checkpoint-{epoch}.h5")
+        )
+    )
+
+# Horovod: write logs on worker 0.
+verbose = 1 if hvd.rank() == 0 else 0
+
+# Train the model.
+# Horovod: adjust number of steps based on number of GPUs.
+mnist_model.fit(
+    dataset,
+    steps_per_epoch=args.steps_per_epoch // hvd.size(),
+    callbacks=callbacks,
+    epochs=args.epochs,
+    verbose=verbose,
+)

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/estimator_train/dummy_train.py

@@ -1,30 +0,0 @@
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-import argparse
-import os
-
-print("*********************************************************")
-print("Hello Azure ML!")
-
-parser = argparse.ArgumentParser()
-parser.add_argument('--datadir', type=str, help="data directory")
-parser.add_argument('--output', type=str, help="output")
-args = parser.parse_args()
-
-print("Argument 1: %s" % args.datadir)
-print("Argument 2: %s" % args.output)
-
-if not (args.output is None):
-    os.makedirs(args.output, exist_ok=True)
-    print("%s created" % args.output)
-
-try:
-    from azureml.core import Run
-    run = Run.get_context()
-    print("Log Fibonacci numbers.")
-    run.log_list('Fibonacci numbers', [0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
-    run.complete()
-except:
-    print("Warning: you need to install Azure ML SDK in order to log metrics.")
-
-print("*********************************************************")

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/publish_run_compare/compare.py

@@ -22,3 +22,6 @@ print("Argument 4: %s" % args.pipeline_param)
 if not (args.output_compare is None):
     os.makedirs(args.output_compare, exist_ok=True)
     print("%s created" % args.output_compare)
+
+with open(os.path.join(args.output_compare, 'compare.txt'), 'w') as fw:
+    fw.write('here is the compare result')

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/publish_run_extract/extract.py

@@ -19,3 +19,8 @@ print("Argument 2: %s" % args.output_extract)
 if not (args.output_extract is None):
     os.makedirs(args.output_extract, exist_ok=True)
     print("%s created" % args.output_extract)
+
+with open(os.path.join(args.input_extract, '20news.pkl'), 'rb') as f:
+    content = f.read()
+    with open(os.path.join(args.output_extract, '20news.pkl'), 'wb') as fw:
+        fw.write(content)

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/publish_run_train/train.py

@@ -20,3 +20,8 @@ print("Argument 2: %s" % args.output_train)
 if not (args.output_train is None):
     os.makedirs(args.output_train, exist_ok=True)
     print("%s created" % args.output_train)
+
+with open(os.path.join(args.input_data, '20news.pkl'), 'rb') as f:
+    content = f.read()
+    with open(os.path.join(args.output_train, '20news.pkl'), 'wb') as fw:
+        fw.write(content)

how-to-use-azureml/machine-learning-pipelines/nyc-taxi-data-regression-model-building/nyc-taxi-data-regression-model-building.ipynb

@@ -284,7 +284,7 @@
         "# Specify CondaDependencies obj, add necessary packages\n",
         "aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(\n",
         "    conda_packages=['pandas','scikit-learn'], \n",
-        "    pip_packages=['azureml-sdk[automl,explain]', 'pyarrow'])\n",
+        "    pip_packages=['azureml-sdk[automl]', 'pyarrow'])\n",
         "\n",
         "print (\"Run configuration created.\")"
       ]

how-to-use-azureml/machine-learning-pipelines/parallel-run/file-dataset-image-inference-mnist.ipynb

@@ -180,7 +180,9 @@
       "metadata": {},
       "source": [
         "### Create a FileDataset\n",
-        "A [FileDataset](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.filedataset?view=azure-ml-py) references single or multiple files in your datastores or public urls. The files can be of any format. FileDataset provides you with the ability to download or mount the files to your compute. By creating a dataset, you create a reference to the data source location. If you applied any subsetting transformations to the dataset, they will be stored in the dataset as well. The data remains in its existing location, so no extra storage cost is incurred."
+        "A [FileDataset](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.filedataset?view=azure-ml-py) references single or multiple files in your datastores or public urls. The files can be of any format. FileDataset provides you with the ability to download or mount the files to your compute. By creating a dataset, you create a reference to the data source location. If you applied any subsetting transformations to the dataset, they will be stored in the dataset as well. The data remains in its existing location, so no extra storage cost is incurred.",
+        "\n",
+        "You can use dataset objects as inputs. Register the datasets to the workspace if you want to reuse them later."
       ]
     },
     {

how-to-use-azureml/machine-learning-pipelines/parallel-run/tabular-dataset-inference-iris.ipynb

@@ -160,7 +160,8 @@
       "metadata": {},
       "source": [
         "### Create a TabularDataset\n",
-        "A [TabularDataSet](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.tabulardataset?view=azure-ml-py) references single or multiple files which contain data in a tabular structure (ie like CSV files) in your datastores or public urls. TabularDatasets provides you with the ability to download or mount the files to your compute. By creating a dataset, you create a reference to the data source location. If you applied any subsetting transformations to the dataset, they will be stored in the dataset as well. The data remains in its existing location, so no extra storage cost is incurred."
+        "A [TabularDataSet](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.tabulardataset?view=azure-ml-py) references single or multiple files which contain data in a tabular structure (ie like CSV files) in your datastores or public urls. TabularDatasets provides you with the ability to download or mount the files to your compute. By creating a dataset, you create a reference to the data source location. If you applied any subsetting transformations to the dataset, they will be stored in the dataset as well. The data remains in its existing location, so no extra storage cost is incurred.\n",
+        "You can use dataset objects as inputs. Register the datasets to the workspace if you want to reuse them later."
       ]
     },
     {
@@ -175,8 +176,7 @@
         "\n",
         "path_on_datastore = iris_data.path('iris/')\n",
         "input_iris_ds = Dataset.Tabular.from_delimited_files(path=path_on_datastore, validate=False)\n",
-        "registered_iris_ds = input_iris_ds.register(ws, iris_ds_name, create_new_version=True)\n",
-        "named_iris_ds = registered_iris_ds.as_named_input(iris_ds_name)"
+        "named_iris_ds = input_iris_ds.as_named_input(iris_ds_name)"
       ]
     },
     {

how-to-use-azureml/machine-learning-pipelines/pipeline-style-transfer/mpi_scripts/neural_style.py

@@ -1,185 +0,0 @@
-# Original source: https://github.com/pytorch/examples/blob/master/fast_neural_style/neural_style/neural_style.py
-import argparse
-import os
-import sys
-import re
-
-from PIL import Image
-import torch
-from torchvision import transforms
-
-
-def load_image(filename, size=None, scale=None):
-    img = Image.open(filename)
-    if size is not None:
-        img = img.resize((size, size), Image.ANTIALIAS)
-    elif scale is not None:
-        img = img.resize((int(img.size[0] / scale), int(img.size[1] / scale)), Image.ANTIALIAS)
-    return img
-
-
-def save_image(filename, data):
-    img = data.clone().clamp(0, 255).numpy()
-    img = img.transpose(1, 2, 0).astype("uint8")
-    img = Image.fromarray(img)
-    img.save(filename)
-
-
-class TransformerNet(torch.nn.Module):
-    def __init__(self):
-        super(TransformerNet, self).__init__()
-        # Initial convolution layers
-        self.conv1 = ConvLayer(3, 32, kernel_size=9, stride=1)
-        self.in1 = torch.nn.InstanceNorm2d(32, affine=True)
-        self.conv2 = ConvLayer(32, 64, kernel_size=3, stride=2)
-        self.in2 = torch.nn.InstanceNorm2d(64, affine=True)
-        self.conv3 = ConvLayer(64, 128, kernel_size=3, stride=2)
-        self.in3 = torch.nn.InstanceNorm2d(128, affine=True)
-        # Residual layers
-        self.res1 = ResidualBlock(128)
-        self.res2 = ResidualBlock(128)
-        self.res3 = ResidualBlock(128)
-        self.res4 = ResidualBlock(128)
-        self.res5 = ResidualBlock(128)
-        # Upsampling Layers
-        self.deconv1 = UpsampleConvLayer(128, 64, kernel_size=3, stride=1, upsample=2)
-        self.in4 = torch.nn.InstanceNorm2d(64, affine=True)
-        self.deconv2 = UpsampleConvLayer(64, 32, kernel_size=3, stride=1, upsample=2)
-        self.in5 = torch.nn.InstanceNorm2d(32, affine=True)
-        self.deconv3 = ConvLayer(32, 3, kernel_size=9, stride=1)
-        # Non-linearities
-        self.relu = torch.nn.ReLU()
-
-    def forward(self, X):
-        y = self.relu(self.in1(self.conv1(X)))
-        y = self.relu(self.in2(self.conv2(y)))
-        y = self.relu(self.in3(self.conv3(y)))
-        y = self.res1(y)
-        y = self.res2(y)
-        y = self.res3(y)
-        y = self.res4(y)
-        y = self.res5(y)
-        y = self.relu(self.in4(self.deconv1(y)))
-        y = self.relu(self.in5(self.deconv2(y)))
-        y = self.deconv3(y)
-        return y
-
-
-class ConvLayer(torch.nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super(ConvLayer, self).__init__()
-        reflection_padding = kernel_size // 2
-        self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
-        self.conv2d = torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride)
-
-    def forward(self, x):
-        out = self.reflection_pad(x)
-        out = self.conv2d(out)
-        return out
-
-
-class ResidualBlock(torch.nn.Module):
-    """ResidualBlock
-    introduced in: https://arxiv.org/abs/1512.03385
-    recommended architecture: http://torch.ch/blog/2016/02/04/resnets.html
-    """
-
-    def __init__(self, channels):
-        super(ResidualBlock, self).__init__()
-        self.conv1 = ConvLayer(channels, channels, kernel_size=3, stride=1)
-        self.in1 = torch.nn.InstanceNorm2d(channels, affine=True)
-        self.conv2 = ConvLayer(channels, channels, kernel_size=3, stride=1)
-        self.in2 = torch.nn.InstanceNorm2d(channels, affine=True)
-        self.relu = torch.nn.ReLU()
-
-    def forward(self, x):
-        residual = x
-        out = self.relu(self.in1(self.conv1(x)))
-        out = self.in2(self.conv2(out))
-        out = out + residual
-        return out
-
-
-class UpsampleConvLayer(torch.nn.Module):
-    """UpsampleConvLayer
-    Upsamples the input and then does a convolution. This method gives better results
-    compared to ConvTranspose2d.
-    ref: http://distill.pub/2016/deconv-checkerboard/
-    """
-
-    def __init__(self, in_channels, out_channels, kernel_size, stride, upsample=None):
-        super(UpsampleConvLayer, self).__init__()
-        self.upsample = upsample
-        if upsample:
-            self.upsample_layer = torch.nn.Upsample(mode='nearest', scale_factor=upsample)
-        reflection_padding = kernel_size // 2
-        self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
-        self.conv2d = torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride)
-
-    def forward(self, x):
-        x_in = x
-        if self.upsample:
-            x_in = self.upsample_layer(x_in)
-        out = self.reflection_pad(x_in)
-        out = self.conv2d(out)
-        return out
-
-
-def stylize(args):
-    device = torch.device("cuda" if args.cuda else "cpu")
-    with torch.no_grad():
-        style_model = TransformerNet()
-        state_dict = torch.load(os.path.join(args.model_dir, args.style + ".pth"))
-        # remove saved deprecated running_* keys in InstanceNorm from the checkpoint
-        for k in list(state_dict.keys()):
-            if re.search(r'in\d+\.running_(mean|var)$', k):
-                del state_dict[k]
-        style_model.load_state_dict(state_dict)
-        style_model.to(device)
-
-        filenames = os.listdir(args.content_dir)
-
-        for filename in filenames:
-            print("Processing {}".format(filename))
-            full_path = os.path.join(args.content_dir, filename)
-            content_image = load_image(full_path, scale=args.content_scale)
-            content_transform = transforms.Compose([
-                transforms.ToTensor(),
-                transforms.Lambda(lambda x: x.mul(255))
-            ])
-            content_image = content_transform(content_image)
-            content_image = content_image.unsqueeze(0).to(device)
-
-            output = style_model(content_image).cpu()
-
-            output_path = os.path.join(args.output_dir, filename)
-            save_image(output_path, output[0])
-
-
-def main():
-    arg_parser = argparse.ArgumentParser(description="parser for fast-neural-style")
-
-    arg_parser.add_argument("--content-scale", type=float, default=None,
-                            help="factor for scaling down the content image")
-    arg_parser.add_argument("--model-dir", type=str, required=True,
-                            help="saved model to be used for stylizing the image.")
-    arg_parser.add_argument("--cuda", type=int, required=True,
-                            help="set it to 1 for running on GPU, 0 for CPU")
-    arg_parser.add_argument("--style", type=str,
-                            help="style name")
-
-    arg_parser.add_argument("--content-dir", type=str, required=True,
-                            help="directory holding the images")
-    arg_parser.add_argument("--output-dir", type=str, required=True,
-                            help="directory holding the output images")
-    args = arg_parser.parse_args()
-
-    if args.cuda and not torch.cuda.is_available():
-        print("ERROR: cuda is not available, try running on CPU")
-        sys.exit(1)
-    os.makedirs(args.output_dir, exist_ok=True)
-    stylize(args)
-
-
-if __name__ == "__main__":
-    main()

how-to-use-azureml/machine-learning-pipelines/pipeline-style-transfer/mpi_scripts/neural_style_mpi.py

@@ -1,207 +0,0 @@
-# Original source: https://github.com/pytorch/examples/blob/master/fast_neural_style/neural_style/neural_style.py
-import argparse
-import os
-import sys
-import re
-
-from PIL import Image
-import torch
-from torchvision import transforms
-
-from mpi4py import MPI
-
-
-def load_image(filename, size=None, scale=None):
-    img = Image.open(filename)
-    if size is not None:
-        img = img.resize((size, size), Image.ANTIALIAS)
-    elif scale is not None:
-        img = img.resize((int(img.size[0] / scale), int(img.size[1] / scale)), Image.ANTIALIAS)
-    return img
-
-
-def save_image(filename, data):
-    img = data.clone().clamp(0, 255).numpy()
-    img = img.transpose(1, 2, 0).astype("uint8")
-    img = Image.fromarray(img)
-    img.save(filename)
-
-
-class TransformerNet(torch.nn.Module):
-    def __init__(self):
-        super(TransformerNet, self).__init__()
-        # Initial convolution layers
-        self.conv1 = ConvLayer(3, 32, kernel_size=9, stride=1)
-        self.in1 = torch.nn.InstanceNorm2d(32, affine=True)
-        self.conv2 = ConvLayer(32, 64, kernel_size=3, stride=2)
-        self.in2 = torch.nn.InstanceNorm2d(64, affine=True)
-        self.conv3 = ConvLayer(64, 128, kernel_size=3, stride=2)
-        self.in3 = torch.nn.InstanceNorm2d(128, affine=True)
-        # Residual layers
-        self.res1 = ResidualBlock(128)
-        self.res2 = ResidualBlock(128)
-        self.res3 = ResidualBlock(128)
-        self.res4 = ResidualBlock(128)
-        self.res5 = ResidualBlock(128)
-        # Upsampling Layers
-        self.deconv1 = UpsampleConvLayer(128, 64, kernel_size=3, stride=1, upsample=2)
-        self.in4 = torch.nn.InstanceNorm2d(64, affine=True)
-        self.deconv2 = UpsampleConvLayer(64, 32, kernel_size=3, stride=1, upsample=2)
-        self.in5 = torch.nn.InstanceNorm2d(32, affine=True)
-        self.deconv3 = ConvLayer(32, 3, kernel_size=9, stride=1)
-        # Non-linearities
-        self.relu = torch.nn.ReLU()
-
-    def forward(self, X):
-        y = self.relu(self.in1(self.conv1(X)))
-        y = self.relu(self.in2(self.conv2(y)))
-        y = self.relu(self.in3(self.conv3(y)))
-        y = self.res1(y)
-        y = self.res2(y)
-        y = self.res3(y)
-        y = self.res4(y)
-        y = self.res5(y)
-        y = self.relu(self.in4(self.deconv1(y)))
-        y = self.relu(self.in5(self.deconv2(y)))
-        y = self.deconv3(y)
-        return y
-
-
-class ConvLayer(torch.nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super(ConvLayer, self).__init__()
-        reflection_padding = kernel_size // 2
-        self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
-        self.conv2d = torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride)
-
-    def forward(self, x):
-        out = self.reflection_pad(x)
-        out = self.conv2d(out)
-        return out
-
-
-class ResidualBlock(torch.nn.Module):
-    """ResidualBlock
-    introduced in: https://arxiv.org/abs/1512.03385
-    recommended architecture: http://torch.ch/blog/2016/02/04/resnets.html
-    """
-
-    def __init__(self, channels):
-        super(ResidualBlock, self).__init__()
-        self.conv1 = ConvLayer(channels, channels, kernel_size=3, stride=1)
-        self.in1 = torch.nn.InstanceNorm2d(channels, affine=True)
-        self.conv2 = ConvLayer(channels, channels, kernel_size=3, stride=1)
-        self.in2 = torch.nn.InstanceNorm2d(channels, affine=True)
-        self.relu = torch.nn.ReLU()
-
-    def forward(self, x):
-        residual = x
-        out = self.relu(self.in1(self.conv1(x)))
-        out = self.in2(self.conv2(out))
-        out = out + residual
-        return out
-
-
-class UpsampleConvLayer(torch.nn.Module):
-    """UpsampleConvLayer
-    Upsamples the input and then does a convolution. This method gives better results
-    compared to ConvTranspose2d.
-    ref: http://distill.pub/2016/deconv-checkerboard/
-    """
-
-    def __init__(self, in_channels, out_channels, kernel_size, stride, upsample=None):
-        super(UpsampleConvLayer, self).__init__()
-        self.upsample = upsample
-        if upsample:
-            self.upsample_layer = torch.nn.Upsample(mode='nearest', scale_factor=upsample)
-        reflection_padding = kernel_size // 2
-        self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
-        self.conv2d = torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride)
-
-    def forward(self, x):
-        x_in = x
-        if self.upsample:
-            x_in = self.upsample_layer(x_in)
-        out = self.reflection_pad(x_in)
-        out = self.conv2d(out)
-        return out
-
-
-def stylize(args, comm):
-
-    rank = comm.Get_rank()
-    size = comm.Get_size()
-
-    device = torch.device("cuda" if args.cuda else "cpu")
-    with torch.no_grad():
-        style_model = TransformerNet()
-        state_dict = torch.load(os.path.join(args.model_dir, args.style + ".pth"))
-        # remove saved deprecated running_* keys in InstanceNorm from the checkpoint
-        for k in list(state_dict.keys()):
-            if re.search(r'in\d+\.running_(mean|var)$', k):
-                del state_dict[k]
-        style_model.load_state_dict(state_dict)
-        style_model.to(device)
-
-        filenames = os.listdir(args.content_dir)
-        filenames = sorted(filenames)
-        partition_size = len(filenames) // size
-        partitioned_filenames = filenames[rank * partition_size: (rank + 1) * partition_size]
-        print("RANK {} - is processing {} images out of the total {}".format(rank, len(partitioned_filenames),
-                                                                             len(filenames)))
-
-        output_paths = []
-        for filename in partitioned_filenames:
-            # print("Processing {}".format(filename))
-            full_path = os.path.join(args.content_dir, filename)
-            content_image = load_image(full_path, scale=args.content_scale)
-            content_transform = transforms.Compose([
-                transforms.ToTensor(),
-                transforms.Lambda(lambda x: x.mul(255))
-            ])
-            content_image = content_transform(content_image)
-            content_image = content_image.unsqueeze(0).to(device)
-
-            output = style_model(content_image).cpu()
-
-            output_path = os.path.join(args.output_dir, filename)
-            save_image(output_path, output[0])
-
-            output_paths.append(output_path)
-
-        print("RANK {} - number of pre-aggregated output files {}".format(rank, len(output_paths)))
-
-        output_paths_list = comm.gather(output_paths, root=0)
-
-        if rank == 0:
-            print("RANK {} - number of aggregated output files {}".format(rank, len(output_paths_list)))
-            print("RANK {} - end".format(rank))
-
-
-def main():
-    arg_parser = argparse.ArgumentParser(description="parser for fast-neural-style")
-
-    arg_parser.add_argument("--content-scale", type=float, default=None,
-                            help="factor for scaling down the content image")
-    arg_parser.add_argument("--model-dir", type=str, required=True,
-                            help="saved model to be used for stylizing the image.")
-    arg_parser.add_argument("--cuda", type=int, required=True,
-                            help="set it to 1 for running on GPU, 0 for CPU")
-    arg_parser.add_argument("--style", type=str, help="style name")
-    arg_parser.add_argument("--content-dir", type=str, required=True,
-                            help="directory holding the images")
-    arg_parser.add_argument("--output-dir", type=str, required=True,
-                            help="directory holding the output images")
-    args = arg_parser.parse_args()
-
-    comm = MPI.COMM_WORLD
-
-    if args.cuda and not torch.cuda.is_available():
-        print("ERROR: cuda is not available, try running on CPU")
-        sys.exit(1)
-    os.makedirs(args.output_dir, exist_ok=True)
-    stylize(args, comm)
-
-
-if __name__ == "__main__":
-    main()

how-to-use-azureml/machine-learning-pipelines/pipeline-style-transfer/pipeline-style-transfer-mpi.ipynb

@@ -1,728 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/machine-learning-pipelines/pipeline-style-transfer/pipeline-style-transfer-mpi.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Neural style transfer on video\n",
-        "Using modified code from `pytorch`'s neural style [example](https://pytorch.org/tutorials/advanced/neural_style_tutorial.html), we show how to setup a pipeline for doing style transfer on video. The pipeline has following steps:\n",
-        "1. Split a video into images\n",
-        "2. Run neural style on each image using one of the provided models (from `pytorch` pretrained models for this example).\n",
-        "3. Stitch the image back into a video."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Prerequisites\n",
-        "If you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, make sure you go through the configuration Notebook located at https://github.com/Azure/MachineLearningNotebooks first if you haven't. This sets you up with a working config file that has information on your workspace, subscription id, etc. "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Initialize Workspace\n",
-        "\n",
-        "Initialize a workspace object from persisted configuration."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "from azureml.core import Workspace, Experiment\n",
-        "\n",
-        "ws = Workspace.from_config()\n",
-        "print('Workspace name: ' + ws.name, \n",
-        "      'Azure region: ' + ws.location, \n",
-        "      'Subscription id: ' + ws.subscription_id, \n",
-        "      'Resource group: ' + ws.resource_group, sep = '\\n')\n",
-        "\n",
-        "scripts_folder = \"mpi_scripts\"\n",
-        "\n",
-        "if not os.path.isdir(scripts_folder):\n",
-        "    os.mkdir(scripts_folder)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.compute import AmlCompute, ComputeTarget\n",
-        "from azureml.core.datastore import Datastore\n",
-        "from azureml.data.data_reference import DataReference\n",
-        "from azureml.pipeline.core import Pipeline, PipelineData\n",
-        "from azureml.pipeline.steps import PythonScriptStep, MpiStep\n",
-        "from azureml.core.runconfig import CondaDependencies, RunConfiguration\n",
-        "from azureml.core.compute_target import ComputeTargetException"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Create or use existing compute"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# AmlCompute\n",
-        "cpu_cluster_name = \"cpu-cluster\"\n",
-        "try:\n",
-        "    cpu_cluster = AmlCompute(ws, cpu_cluster_name)\n",
-        "    print(\"found existing cluster.\")\n",
-        "except ComputeTargetException:\n",
-        "    print(\"creating new cluster\")\n",
-        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_D2_v2\",\n",
-        "                                                                    max_nodes = 1)\n",
-        "\n",
-        "    # create the cluster\n",
-        "    cpu_cluster = ComputeTarget.create(ws, cpu_cluster_name, provisioning_config)\n",
-        "    cpu_cluster.wait_for_completion(show_output=True)\n",
-        "    \n",
-        "# AmlCompute\n",
-        "gpu_cluster_name = \"gpu-cluster\"\n",
-        "try:\n",
-        "    gpu_cluster = AmlCompute(ws, gpu_cluster_name)\n",
-        "    print(\"found existing cluster.\")\n",
-        "except ComputeTargetException:\n",
-        "    print(\"creating new cluster\")\n",
-        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_NC6\",\n",
-        "                                                                    max_nodes = 3)\n",
-        "\n",
-        "    # create the cluster\n",
-        "    gpu_cluster = ComputeTarget.create(ws, gpu_cluster_name, provisioning_config)\n",
-        "    gpu_cluster.wait_for_completion(show_output=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Python Scripts\n",
-        "We use an edited version of `neural_style_mpi.py` (original is [here](https://github.com/pytorch/examples/blob/master/fast_neural_style/neural_style/neural_style.py)). Scripts to split and stitch the video are thin wrappers to calls to `ffmpeg`. These scripts are also located in the \"scripts_folder\".\n",
-        "\n",
-        "We install `ffmpeg` through conda dependencies."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%writefile $scripts_folder/process_video.py\n",
-        "import argparse\n",
-        "import glob\n",
-        "import os\n",
-        "import subprocess\n",
-        "\n",
-        "parser = argparse.ArgumentParser(description=\"Process input video\")\n",
-        "parser.add_argument('--input_video', required=True)\n",
-        "parser.add_argument('--output_audio', required=True)\n",
-        "parser.add_argument('--output_images', required=True)\n",
-        "\n",
-        "args = parser.parse_args()\n",
-        "\n",
-        "os.makedirs(args.output_audio, exist_ok=True)\n",
-        "os.makedirs(args.output_images, exist_ok=True)\n",
-        "\n",
-        "subprocess.run(\"ffmpeg -i {} {}/video.aac\"\n",
-        "              .format(args.input_video, args.output_audio),\n",
-        "               shell=True, check=True\n",
-        "              )\n",
-        "\n",
-        "subprocess.run(\"ffmpeg -i {} {}/%05d_video.jpg -hide_banner\"\n",
-        "              .format(args.input_video, args.output_images),\n",
-        "               shell=True, check=True\n",
-        "              )"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%writefile $scripts_folder/stitch_video.py\n",
-        "import argparse\n",
-        "import os\n",
-        "import subprocess\n",
-        "\n",
-        "parser = argparse.ArgumentParser(description=\"Process input video\")\n",
-        "parser.add_argument('--images_dir', required=True)\n",
-        "parser.add_argument('--input_audio', required=True)\n",
-        "parser.add_argument('--output_dir', required=True)\n",
-        "\n",
-        "args = parser.parse_args()\n",
-        "\n",
-        "os.makedirs(args.output_dir, exist_ok=True)\n",
-        "\n",
-        "subprocess.run(\"ffmpeg -framerate 30 -i {}/%05d_video.jpg -c:v libx264 -profile:v high -crf 20 -pix_fmt yuv420p \"\n",
-        "               \"-y {}/video_without_audio.mp4\"\n",
-        "               .format(args.images_dir, args.output_dir),\n",
-        "               shell=True, check=True\n",
-        "              )\n",
-        "\n",
-        "subprocess.run(\"ffmpeg -i {}/video_without_audio.mp4 -i {}/video.aac -map 0:0 -map 1:0 -vcodec \"\n",
-        "               \"copy -acodec copy -y {}/video_with_audio.mp4\"\n",
-        "               .format(args.output_dir, args.input_audio, args.output_dir),\n",
-        "               shell=True, check=True\n",
-        "              )"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "The sample video **organutan.mp4** is stored at a publicly shared datastore. We are registering the datastore below. If you want to take a look at the original video, click here. (https://pipelinedata.blob.core.windows.net/sample-videos/orangutan.mp4)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# datastore for input video\n",
-        "account_name = \"pipelinedata\"\n",
-        "video_ds = Datastore.register_azure_blob_container(ws, \"videos\", \"sample-videos\",\n",
-        "                                            account_name=account_name, overwrite=True)\n",
-        "\n",
-        "# datastore for models\n",
-        "models_ds = Datastore.register_azure_blob_container(ws, \"models\", \"styletransfer\", \n",
-        "                                                        account_name=\"pipelinedata\", \n",
-        "                                                        overwrite=True)\n",
-        "                                                        \n",
-        "# downloaded models from https://pytorch.org/tutorials/advanced/neural_style_tutorial.html are kept here\n",
-        "models_dir = DataReference(data_reference_name=\"models\", datastore=models_ds, \n",
-        "                           path_on_datastore=\"saved_models\", mode=\"download\")\n",
-        "\n",
-        "# the default blob store attached to a workspace\n",
-        "default_datastore = ws.get_default_datastore()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Sample video"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "video_name=os.getenv(\"STYLE_TRANSFER_VIDEO_NAME\", \"orangutan.mp4\") \n",
-        "orangutan_video = DataReference(datastore=video_ds,\n",
-        "                            data_reference_name=\"video\",\n",
-        "                            path_on_datastore=video_name, mode=\"download\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "cd = CondaDependencies()\n",
-        "\n",
-        "cd.add_channel(\"conda-forge\")\n",
-        "cd.add_conda_package(\"ffmpeg\")\n",
-        "\n",
-        "cd.add_channel(\"pytorch\")\n",
-        "cd.add_conda_package(\"pytorch\")\n",
-        "cd.add_conda_package(\"torchvision\")\n",
-        "\n",
-        "# Runconfig\n",
-        "amlcompute_run_config = RunConfiguration(conda_dependencies=cd)\n",
-        "amlcompute_run_config.environment.docker.enabled = True\n",
-        "amlcompute_run_config.environment.docker.base_image = \"pytorch/pytorch\"\n",
-        "amlcompute_run_config.environment.spark.precache_packages = False"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ffmpeg_audio = PipelineData(name=\"ffmpeg_audio\", datastore=default_datastore)\n",
-        "ffmpeg_images = PipelineData(name=\"ffmpeg_images\", datastore=default_datastore)\n",
-        "processed_images = PipelineData(name=\"processed_images\", datastore=default_datastore)\n",
-        "output_video = PipelineData(name=\"output_video\", datastore=default_datastore)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Define tweakable parameters to pipeline\n",
-        "These parameters can be changed when the pipeline is published and rerun from a REST call"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.pipeline.core.graph import PipelineParameter\n",
-        "# create a parameter for style (one of \"candy\", \"mosaic\", \"rain_princess\", \"udnie\") to transfer the images to\n",
-        "style_param = PipelineParameter(name=\"style\", default_value=\"mosaic\")\n",
-        "# create a parameter for the number of nodes to use in step no. 2 (style transfer)\n",
-        "nodecount_param = PipelineParameter(name=\"nodecount\", default_value=1)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "split_video_step = PythonScriptStep(\n",
-        "    name=\"split video\",\n",
-        "    script_name=\"process_video.py\",\n",
-        "    arguments=[\"--input_video\", orangutan_video,\n",
-        "               \"--output_audio\", ffmpeg_audio,\n",
-        "               \"--output_images\", ffmpeg_images,\n",
-        "              ],\n",
-        "    compute_target=cpu_cluster,\n",
-        "    inputs=[orangutan_video],\n",
-        "    outputs=[ffmpeg_images, ffmpeg_audio],\n",
-        "    runconfig=amlcompute_run_config,\n",
-        "    source_directory=scripts_folder\n",
-        ")\n",
-        "\n",
-        "# create a MPI step for distributing style transfer step across multiple nodes in AmlCompute \n",
-        "# using 'nodecount_param' PipelineParameter\n",
-        "distributed_style_transfer_step = MpiStep(\n",
-        "    name=\"mpi style transfer\",\n",
-        "    script_name=\"neural_style_mpi.py\",\n",
-        "    arguments=[\"--content-dir\", ffmpeg_images,\n",
-        "               \"--output-dir\", processed_images,\n",
-        "               \"--model-dir\", models_dir,\n",
-        "               \"--style\", style_param,\n",
-        "               \"--cuda\", 1\n",
-        "              ],\n",
-        "    compute_target=gpu_cluster,\n",
-        "    node_count=nodecount_param, \n",
-        "    process_count_per_node=1,\n",
-        "    inputs=[models_dir, ffmpeg_images],\n",
-        "    outputs=[processed_images],\n",
-        "    pip_packages=[\"mpi4py\", \"torch\", \"torchvision\"],\n",
-        "    use_gpu=True,\n",
-        "    source_directory=scripts_folder\n",
-        ")\n",
-        "\n",
-        "stitch_video_step = PythonScriptStep(\n",
-        "    name=\"stitch\",\n",
-        "    script_name=\"stitch_video.py\",\n",
-        "    arguments=[\"--images_dir\", processed_images, \n",
-        "               \"--input_audio\", ffmpeg_audio, \n",
-        "               \"--output_dir\", output_video],\n",
-        "    compute_target=cpu_cluster,\n",
-        "    inputs=[processed_images, ffmpeg_audio],\n",
-        "    outputs=[output_video],\n",
-        "    runconfig=amlcompute_run_config,\n",
-        "    source_directory=scripts_folder\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Run the pipeline"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "pipeline = Pipeline(workspace=ws, steps=[stitch_video_step])\n",
-        "# submit the pipeline and provide values for the PipelineParameters used in the pipeline\n",
-        "pipeline_run = Experiment(ws, 'style_transfer').submit(pipeline, pipeline_parameters={\"style\": \"mosaic\", \"nodecount\": 3})"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Monitor using widget"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.widgets import RunDetails\n",
-        "RunDetails(pipeline_run).show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Downloads the video in `output_video` folder"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Download output video"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "def download_video(run, target_dir=None):\n",
-        "    stitch_run = run.find_step_run(\"stitch\")[0]\n",
-        "    port_data = stitch_run.get_output_data(\"output_video\")\n",
-        "    port_data.download(target_dir, show_progress=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "pipeline_run.wait_for_completion()\n",
-        "download_video(pipeline_run, \"output_video_mosaic\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Publish pipeline"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "published_pipeline = pipeline_run.publish_pipeline(\n",
-        "    name=\"batch score style transfer\", description=\"style transfer\", version=\"1.0\")\n",
-        "\n",
-        "published_pipeline"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Get published pipeline\n",
-        "\n",
-        "You can get the published pipeline using **pipeline id**.\n",
-        "\n",
-        "To get all the published pipelines for a given workspace(ws): \n",
-        "```css\n",
-        "all_pub_pipelines = PublishedPipeline.get_all(ws)\n",
-        "```"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.pipeline.core import PublishedPipeline\n",
-        "\n",
-        "pipeline_id = published_pipeline.id # use your published pipeline id\n",
-        "published_pipeline = PublishedPipeline.get(ws, pipeline_id)\n",
-        "\n",
-        "published_pipeline"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#  Re-run pipeline through REST calls for other styles"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Get AAD token\n",
-        "[This notebook](https://aka.ms/pl-restep-auth) shows how to authenticate to AML workspace."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.authentication import InteractiveLoginAuthentication\n",
-        "import requests\n",
-        "\n",
-        "auth = InteractiveLoginAuthentication()\n",
-        "aad_token = auth.get_authentication_header()\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Get endpoint URL"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "rest_endpoint = published_pipeline.endpoint"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Send request and monitor"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Run the pipeline using PipelineParameter values style='candy' and nodecount=2"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "response = requests.post(rest_endpoint, \n",
-        "                         headers=aad_token,\n",
-        "                         json={\"ExperimentName\": \"style_transfer\",\n",
-        "                               \"ParameterAssignments\": {\"style\": \"candy\", \"nodecount\": 2}})"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "try:\n",
-        "    response.raise_for_status()\n",
-        "except Exception:    \n",
-        "    raise Exception('Received bad response from the endpoint: {}\\n'\n",
-        "                    'Response Code: {}\\n'\n",
-        "                    'Headers: {}\\n'\n",
-        "                    'Content: {}'.format(rest_endpoint, response.status_code, response.headers, response.content))\n",
-        "\n",
-        "run_id = response.json().get('Id')\n",
-        "print('Submitted pipeline run: ', run_id)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.pipeline.core.run import PipelineRun\n",
-        "published_pipeline_run_candy = PipelineRun(ws.experiments[\"style_transfer\"], run_id)\n",
-        "RunDetails(published_pipeline_run_candy).show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Run the pipeline using PipelineParameter values style='rain_princess' and nodecount=3"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "response = requests.post(rest_endpoint, \n",
-        "                         headers=aad_token,\n",
-        "                         json={\"ExperimentName\": \"style_transfer\",\n",
-        "                               \"ParameterAssignments\": {\"style\": \"rain_princess\", \"nodecount\": 3}})"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "try:\n",
-        "    response.raise_for_status()\n",
-        "except Exception:    \n",
-        "    raise Exception('Received bad response from the endpoint: {}\\n'\n",
-        "                    'Response Code: {}\\n'\n",
-        "                    'Headers: {}\\n'\n",
-        "                    'Content: {}'.format(rest_endpoint, response.status_code, response.headers, response.content))\n",
-        "\n",
-        "run_id = response.json().get('Id')\n",
-        "print('Submitted pipeline run: ', run_id)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "published_pipeline_run_rain = PipelineRun(ws.experiments[\"style_transfer\"], run_id)\n",
-        "RunDetails(published_pipeline_run_rain).show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Run the pipeline using PipelineParameter values style='udnie' and nodecount=4"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "response = requests.post(rest_endpoint, \n",
-        "                         headers=aad_token,\n",
-        "                         json={\"ExperimentName\": \"style_transfer\",\n",
-        "                               \"ParameterAssignments\": {\"style\": \"udnie\", \"nodecount\": 3}})\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "try:\n",
-        "    response.raise_for_status()\n",
-        "except Exception:    \n",
-        "    raise Exception('Received bad response from the endpoint: {}\\n'\n",
-        "                    'Response Code: {}\\n'\n",
-        "                    'Headers: {}\\n'\n",
-        "                    'Content: {}'.format(rest_endpoint, response.status_code, response.headers, response.content))\n",
-        "\n",
-        "run_id = response.json().get('Id')\n",
-        "print('Submitted pipeline run: ', run_id)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "published_pipeline_run_udnie = PipelineRun(ws.experiments[\"style_transfer\"], run_id)\n",
-        "RunDetails(published_pipeline_run_udnie).show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Download output from re-run"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "published_pipeline_run_candy.wait_for_completion()\n",
-        "published_pipeline_run_rain.wait_for_completion()\n",
-        "published_pipeline_run_udnie.wait_for_completion()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "download_video(published_pipeline_run_candy, target_dir=\"output_video_candy\")\n",
-        "download_video(published_pipeline_run_rain, target_dir=\"output_video_rain_princess\")\n",
-        "download_video(published_pipeline_run_udnie, target_dir=\"output_video_udnie\")"
-      ]
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "balapv mabables"
-      }
-    ],
-    "kernelspec": {
-      "display_name": "Python 3.6",
-      "language": "python",
-      "name": "python36"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.6.7"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

how-to-use-azureml/machine-learning-pipelines/pipeline-style-transfer/pipeline-style-transfer-mpi.yml

@@ -1,7 +0,0 @@
-name: pipeline-style-transfer-mpi
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-pipeline-steps
-  - azureml-widgets
-  - requests

how-to-use-azureml/manage-azureml-service/authentication-in-azureml/authentication-in-azureml.ipynb

@@ -28,6 +28,7 @@
         " 2. Azure CLI Authentication\n",
         " 3. Managed Service Identity (MSI) Authentication\n",
         " 4. Service Principal Authentication\n",
+        " 5. Token Authentication\n",
         " \n",
         "The interactive authentication is suitable for local experimentation on your own computer. Azure CLI authentication is suitable if you are already using Azure CLI for managing Azure resources, and want to sign in only once. The MSI and Service Principal authentication are suitable for automated workflows, for example as part of Azure Devops build."
       ]
@@ -121,6 +122,33 @@
         "               auth=interactive_auth)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Despite having access to the workspace, you may sometimes see the following error when retrieving it:\n",
+        "\n",
+        "```\n",
+        "You are currently logged-in to xxxxxxxx-xxx-xxxx-xxxx-xxxxxxxxxxxx tenant. You don't have access to xxxxxx-xxxx-xxx-xxx-xxxxxxxxxx subscription, please check if it is in this tenant.\n",
+        "```\n",
+        "\n",
+        "This error sometimes occurs when you are trying to access a subscription to which you were recently added. In this case, you need to force authentication again to avoid using a cached authentication token that has not picked up the new permissions. You can do so by setting `force=true` on the `InteractiveLoginAuthentication()` object's constructor as follows:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "forced_interactive_auth = InteractiveLoginAuthentication(tenant_id=\"my-tenant-id\", force=True)\n",
+        "\n",
+        "ws = Workspace(subscription_id=\"my-subscription-id\",\n",
+        "               resource_group=\"my-ml-rg\",\n",
+        "               workspace_name=\"my-ml-workspace\",\n",
+        "               auth=forced_interactive_auth)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -292,6 +320,66 @@
         "See [Register an application with the Microsoft identity platform](https://docs.microsoft.com/en-us/azure/active-directory/develop/quickstart-register-app) quickstart for more details about application registrations. "
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Token Authentication\n",
+        "\n",
+        "When token generation and its refresh needs to be outside on AML SDK, we recommend using Token Authentication. It can be used for getting token for AML or ARM audience. Thus giving more granular control over token generated.\n",
+        "\n",
+        "This authentication class requires users to provide method `get_token_for_audience` which will be called to retrieve the token based on the audience passed.\n",
+        "\n",
+        "Audience that is passed to `get_token_for_audience` can be ARM or AML. Exact value that will be passed as audience will depend on cloud and type for audience."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.authentication import TokenAuthentication, Audience\n",
+        "\n",
+        "# This is a sample method to retrieve token and will be passed to TokenAuthentication\n",
+        "def get_token_for_audience(audience):\n",
+        "    from adal import AuthenticationContext\n",
+        "    client_id = \"my-client-id\"\n",
+        "    client_secret = \"my-client-secret\"\n",
+        "    tenant_id = \"my-tenant-id\"\n",
+        "    auth_context = AuthenticationContext(\"https://login.microsoftonline.com/{}\".format(tenant_id))\n",
+        "    resp = auth_context.acquire_token_with_client_credentials(audience,client_id,client_secret)\n",
+        "    token = resp[\"accessToken\"]\n",
+        "    return token\n",
+        "\n",
+        "\n",
+        "token_auth = TokenAuthentication(get_token_for_audience=get_token_for_audience)\n",
+        "\n",
+        "ws = Workspace(\n",
+        "    subscription_id=\"my-subscription-id\",\n",
+        "    resource_group=\"my-ml-rg\",\n",
+        "    workspace_name=\"my-ml-workspace\",\n",
+        "    auth=token_auth\n",
+        "    )\n",
+        "\n",
+        "print(\"Found workspace {} at location {}\".format(ws.name, ws.location))\n",
+        "\n",
+        "token_aml_audience = token_auth.get_token(Audience.aml)\n",
+        "token_arm_audience = token_auth.get_token(Audience.arm)\n",
+        "\n",
+        "# Value of audience pass to `get_token_for_audience` can be retrieved as follows:\n",
+        "# aud_aml_val = token_auth.get_aml_resource_id() # For AML\n",
+        "# aud_arm_val = token_auth._cloud_type.endpoints.active_directory_resource_id # For ARM\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Token authentication object can be used to retrieve token for either AML or ARM audience,\n",
+        "which can be used by other clients to authenticate to AML or ARM"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -323,7 +411,7 @@
       },
       "outputs": [],
       "source": [
-        "import os, uuid\n",
+        "import uuid\n",
         "\n",
         "local_secret = os.environ.get(\"LOCAL_SECRET\", default = str(uuid.uuid4())) # Use random UUID as a substitute for real secret.\n",
         "keyvault = ws.get_default_keyvault()\n",
@@ -408,7 +496,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core import Experiment, Run\n",
+        "from azureml.core import Experiment\n",
         "from azureml.core.script_run_config import ScriptRunConfig\n",
         "\n",
         "exp = Experiment(workspace = ws, name=\"try-secret\")\n",
@@ -424,13 +512,6 @@
       "source": [
         "Furthermore, you can set and get multiple secrets using set_secrets and get_secrets methods."
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {

how-to-use-azureml/ml-frameworks/chainer/train-hyperparameter-tune-deploy-with-chainer/chainer_mnist.py

@@ -4,6 +4,8 @@ import os
 
 import numpy as np
 
+from utils import download_mnist
+
 import chainer
 from chainer import backend
 from chainer import backends
@@ -17,6 +19,7 @@ from chainer.training import extensions
 from chainer.dataset import concat_examples
 from chainer.backends.cuda import to_cpu
 
+
 from azureml.core.run import Run
 run = Run.get_context()
 
@@ -49,7 +52,7 @@ def main():
     args = parser.parse_args()
 
     # Download the MNIST data if you haven't downloaded it yet
-    train, test = datasets.mnist.get_mnist(withlabel=True, ndim=1)
+    train, test = download_mnist()
 
     gpu_id = args.gpu_id
     batchsize = args.batchsize

how-to-use-azureml/ml-frameworks/chainer/train-hyperparameter-tune-deploy-with-chainer/chainer_score.py

@@ -2,6 +2,8 @@ import numpy as np
 import os
 import json
 
+from utils import download_mnist
+
 from chainer import serializers, using_config, Variable, datasets
 import chainer.functions as F
 import chainer.links as L
@@ -41,7 +43,7 @@ def init():
 def run(input_data):
     i = np.array(json.loads(input_data)['data'])
 
-    _, test = datasets.get_mnist()
+    _, test = download_mnist()
     x = Variable(np.asarray([test[i][0]]))
     y = model(x)
 

how-to-use-azureml/ml-frameworks/chainer/train-hyperparameter-tune-deploy-with-chainer/train-hyperparameter-tune-deploy-with-chainer.ipynb

@@ -136,7 +136,7 @@
         "    # create the cluster\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
-        "    compute_target.wait_for_completion(show_output=True)\n",
+        "compute_target.wait_for_completion(show_output=True)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
         "print(compute_target.get_status().serialize())"
@@ -217,7 +217,8 @@
         "import shutil\n",
         "\n",
         "shutil.copy('chainer_mnist.py', project_folder)\n",
-        "shutil.copy('chainer_score.py', project_folder)"
+        "shutil.copy('chainer_score.py', project_folder)\n",
+        "shutil.copy('utils.py', project_folder)"
       ]
     },
     {
@@ -263,6 +264,7 @@
         "- python=3.6.2\n",
         "- pip:\n",
         "  - azureml-defaults\n",
+        "  - azureml-opendatasets\n",
         "  - chainer==5.1.0\n",
         "  - cupy-cuda90==5.1.0\n",
         "  - mpi4py==3.0.0\n",
@@ -557,6 +559,7 @@
         "cd.add_conda_package('numpy')\n",
         "cd.add_pip_package('chainer==5.1.0')\n",
         "cd.add_pip_package(\"azureml-defaults\")\n",
+        "cd.add_pip_package(\"azureml-opendatasets\")\n",
         "cd.save_to_file(base_directory='./', conda_file_path='myenv.yml')\n",
         "\n",
         "print(cd.serialize_to_string())"
@@ -584,7 +587,8 @@
         "\n",
         "\n",
         "myenv = Environment.from_conda_specification(name=\"myenv\", file_path=\"myenv.yml\")\n",
-        "inference_config = InferenceConfig(entry_script=\"chainer_score.py\", environment=myenv)\n",
+        "inference_config = InferenceConfig(entry_script=\"chainer_score.py\", environment=myenv,\n",
+        "                                   source_directory=project_folder)\n",
         "\n",
         "aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,\n",
         "                                               auth_enabled=True, # this flag generates API keys to secure access\n",
@@ -592,11 +596,11 @@
         "                                               tags={'name': 'mnist', 'framework': 'Chainer'},\n",
         "                                               description='Chainer DNN with MNIST')\n",
         "\n",
-        "service = Model.deploy(workspace=ws, \n",
-        "                           name='chainer-mnist-1', \n",
-        "                           models=[model], \n",
-        "                           inference_config=inference_config, \n",
-        "                           deployment_config=aciconfig)\n",
+        "service = Model.deploy(workspace=ws,\n",
+        "                       name='chainer-mnist-1',\n",
+        "                       models=[model],\n",
+        "                       inference_config=inference_config,\n",
+        "                       deployment_config=aciconfig)\n",
         "service.wait_for_deployment(True)\n",
         "print(service.state)\n",
         "print(service.scoring_uri)"
@@ -606,14 +610,32 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "**Tip: If something goes wrong with the deployment, the first thing to look at is the logs from the service by running the following command:** `print(service.get_logs())`"
+        "**Tip: If something goes wrong with the deployment, the first thing to look at is the logs from the service by running the following command:** "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(service.get_logs())"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "This is the scoring web service endpoint: `print(service.scoring_uri)`"
+        "This is the scoring web service endpoint:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(service.scoring_uri)"
       ]
     },
     {
@@ -667,13 +689,16 @@
         "            res = res.reshape(n_items[0], 1)\n",
         "    return res\n",
         "\n",
-        "os.makedirs('./data/mnist', exist_ok=True)\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename = './data/mnist/test-images.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename = './data/mnist/test-labels.gz')\n",
+        "data_folder = os.path.join(os.getcwd(), 'data/mnist')\n",
+        "os.makedirs(data_folder, exist_ok=True)\n",
         "\n",
-        "X_test = load_data('./data/mnist/test-images.gz', False)\n",
-        "y_test = load_data('./data/mnist/test-labels.gz', True).reshape(-1)\n",
+        "urllib.request.urlretrieve('https://azureopendatastorage.blob.core.windows.net/mnist/t10k-images-idx3-ubyte.gz',\n",
+        "                           filename=os.path.join(data_folder, 't10k-images-idx3-ubyte.gz'))\n",
+        "urllib.request.urlretrieve('https://azureopendatastorage.blob.core.windows.net/mnist/t10k-labels-idx1-ubyte.gz',\n",
+        "                           filename=os.path.join(data_folder, 't10k-labels-idx1-ubyte.gz'))\n",
         "\n",
+        "X_test = load_data(os.path.join(data_folder, 't10k-images-idx3-ubyte.gz'), False) / np.float32(255.0)\n",
+        "y_test = load_data(os.path.join(data_folder, 't10k-labels-idx1-ubyte.gz'), True).reshape(-1)\n",
         "\n",
         "# send a random row from the test set to score\n",
         "random_index = np.random.randint(0, len(X_test)-1)\n",
@@ -742,7 +767,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "swatig"
+        "name": "nagaur"
       }
     ],
     "category": "training",

how-to-use-azureml/ml-frameworks/chainer/train-hyperparameter-tune-deploy-with-chainer/train-hyperparameter-tune-deploy-with-chainer.yml

@@ -10,3 +10,4 @@ dependencies:
   - gzip
   - struct
   - requests
+  - azureml-opendatasets

how-to-use-azureml/ml-frameworks/chainer/train-hyperparameter-tune-deploy-with-chainer/utils.py

@@ -0,0 +1,50 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import glob
+import gzip
+import numpy as np
+import os
+import struct
+
+from azureml.core import Dataset
+from azureml.opendatasets import MNIST
+from chainer.datasets import tuple_dataset
+
+
+# load compressed MNIST gz files and return numpy arrays
+def load_data(filename, label=False):
+    with gzip.open(filename) as gz:
+        struct.unpack('I', gz.read(4))
+        n_items = struct.unpack('>I', gz.read(4))
+        if not label:
+            n_rows = struct.unpack('>I', gz.read(4))[0]
+            n_cols = struct.unpack('>I', gz.read(4))[0]
+            res = np.frombuffer(gz.read(n_items[0] * n_rows * n_cols), dtype=np.uint8)
+            res = res.reshape(n_items[0], n_rows * n_cols)
+        else:
+            res = np.frombuffer(gz.read(n_items[0]), dtype=np.uint8)
+            res = res.reshape(n_items[0], 1)
+    return res
+
+
+def download_mnist():
+    data_folder = os.path.join(os.getcwd(), 'data/mnist')
+    os.makedirs(data_folder, exist_ok=True)
+
+    mnist_file_dataset = MNIST.get_file_dataset()
+    mnist_file_dataset.download(data_folder, overwrite=True)
+
+    X_train = load_data(glob.glob(os.path.join(data_folder, "**/train-images-idx3-ubyte.gz"),
+                        recursive=True)[0], False) / 255.0
+    X_test = load_data(glob.glob(os.path.join(data_folder, "**/t10k-images-idx3-ubyte.gz"),
+                       recursive=True)[0], False) / 255.0
+    y_train = load_data(glob.glob(os.path.join(data_folder, "**/train-labels-idx1-ubyte.gz"),
+                        recursive=True)[0], True).reshape(-1)
+    y_test = load_data(glob.glob(os.path.join(data_folder, "**/t10k-labels-idx1-ubyte.gz"),
+                       recursive=True)[0], True).reshape(-1)
+
+    train = tuple_dataset.TupleDataset(X_train.astype(np.float32), y_train.astype(np.int32))
+    test = tuple_dataset.TupleDataset(X_test.astype(np.float32), y_test.astype(np.int32))
+
+    return train, test

how-to-use-azureml/ml-frameworks/keras/train-hyperparameter-tune-deploy-with-keras/train-hyperparameter-tune-deploy-with-keras.ipynb

@@ -308,9 +308,9 @@
         "    # create the cluster\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
-        "    # can poll for a minimum number of nodes and for a specific timeout. \n",
-        "    # if no min node count is provided it uses the scale settings for the cluster\n",
-        "    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
+        "# can poll for a minimum number of nodes and for a specific timeout. \n",
+        "# if no min node count is provided it uses the scale settings for the cluster\n",
+        "compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
         "print(compute_target.get_status().serialize())"
@@ -1033,7 +1033,16 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "**Tip: If something goes wrong with the deployment, the first thing to look at is the logs from the service by running the following command:** `print(service.get_logs())`"
+        "**Tip: If something goes wrong with the deployment, the first thing to look at is the logs from the service by running the following command:**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(service.get_logs())"
       ]
     },
     {

how-to-use-azureml/ml-frameworks/pytorch/distributed-pytorch-with-distributeddataparallel/distributed-pytorch-with-distributeddataparallel.ipynb

@@ -21,7 +21,8 @@
       "metadata": {},
       "source": [
         "# Distributed PyTorch with DistributedDataParallel\n",
-        "In this tutorial, you will train a PyTorch model on the [MNIST](http://yann.lecun.com/exdb/mnist/) dataset using distributed training with PyTorch's `DistributedDataParallel` module across a GPU cluster. "
+        "\n",
+        "In this tutorial, you will train a PyTorch model on the [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) dataset using distributed training with PyTorch's `DistributedDataParallel` module across a GPU cluster."
       ]
     },
     {
@@ -113,7 +114,7 @@
         "from azureml.core.compute_target import ComputeTargetException\n",
         "\n",
         "# choose a name for your cluster\n",
-        "cluster_name = \"gpu-cluster\"\n",
+        "cluster_name = 'gpu-cluster'\n",
         "\n",
         "try:\n",
         "    compute_target = ComputeTarget(workspace=ws, name=cluster_name)\n",
@@ -139,6 +140,68 @@
         "The above code creates GPU compute. If you instead want to create CPU compute, provide a different VM size to the `vm_size` parameter, such as `STANDARD_D2_V2`."
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Prepare dataset\n",
+        "\n",
+        "Prepare the dataset used for training. We will first download and extract the publicly available CIFAR-10 dataset from the cs.toronto.edu website and then create an Azure ML FileDataset to use the data for training."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Download and extract CIFAR-10 data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import urllib\n",
+        "import tarfile\n",
+        "import os\n",
+        "\n",
+        "url = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'\n",
+        "filename = 'cifar-10-python.tar.gz'\n",
+        "data_root = 'cifar-10'\n",
+        "filepath = os.path.join(data_root, filename)\n",
+        "\n",
+        "if not os.path.isdir(data_root):\n",
+        "    os.makedirs(data_root, exist_ok=True)\n",
+        "    urllib.request.urlretrieve(url, filepath)\n",
+        "    with tarfile.open(filepath, \"r:gz\") as tar:\n",
+        "        tar.extractall(path=data_root)\n",
+        "    os.remove(filepath)  # delete tar.gz file after extraction"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create Azure ML dataset\n",
+        "\n",
+        "The `upload_directory` method will upload the data to a datastore and create a FileDataset from it. In this tutorial we will use the workspace's default datastore."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Dataset\n",
+        "\n",
+        "datastore = ws.get_default_datastore()\n",
+        "dataset = Dataset.File.upload_directory(\n",
+        "    src_dir=data_root, target=(datastore, data_root)\n",
+        ")"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -161,8 +224,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "import os\n",
-        "\n",
         "project_folder = './pytorch-distr'\n",
         "os.makedirs(project_folder, exist_ok=True)"
       ]
@@ -172,26 +233,14 @@
       "metadata": {},
       "source": [
         "### Prepare training script\n",
-        "Now you will need to create your training script. In this tutorial, the script for distributed training of MNIST is already provided for you at `pytorch_mnist.py`. In practice, you should be able to take any custom PyTorch training script as is and run it with Azure ML without having to modify your code.\n",
-        "\n",
-        "However, if you would like to use Azure ML's [metric logging](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#logging) capabilities, you will have to add a small amount of Azure ML logic inside your training script. In this example, at each logging interval, we will log the loss for that minibatch to our Azure ML run.\n",
-        "\n",
-        "To do so, in `pytorch_mnist.py`, we will first access the Azure ML `Run` object within the script:\n",
-        "```Python\n",
-        "from azureml.core.run import Run\n",
-        "run = Run.get_context()\n",
-        "```\n",
-        "Later within the script, we log the loss metric to our run:\n",
-        "```Python\n",
-        "run.log('loss', losses.avg)\n",
-        "```"
+        "Now you will need to create your training script. In this tutorial, the script for distributed training on CIFAR-10 is already provided for you at `train.py`. In practice, you should be able to take any custom PyTorch training script as is and run it with Azure ML without having to modify your code."
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Once your script is ready, copy the training script `pytorch_mnist.py` into the project directory."
+        "Once your script is ready, copy the training script `train.py` into the project directory."
       ]
     },
     {
@@ -202,7 +251,7 @@
       "source": [
         "import shutil\n",
         "\n",
-        "shutil.copy('pytorch_mnist.py', project_folder)"
+        "shutil.copy('train.py', project_folder)"
       ]
     },
     {
@@ -231,26 +280,7 @@
       "source": [
         "### Create an environment\n",
         "\n",
-        "Define a conda environment YAML file with your training script dependencies and create an Azure ML environment."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%writefile conda_dependencies.yml\n",
-        "\n",
-        "channels:\n",
-        "- conda-forge\n",
-        "dependencies:\n",
-        "- python=3.6.2\n",
-        "- pip:\n",
-        "  - azureml-defaults\n",
-        "  - torch==1.6.0\n",
-        "  - torchvision==0.7.0\n",
-        "  - future==0.17.1"
+        "In this tutorial, we will use one of Azure ML's curated PyTorch environments for training. [Curated environments](https://docs.microsoft.com/azure/machine-learning/how-to-use-environments#use-a-curated-environment) are available in your workspace by default. Specifically, we will use the PyTorch 1.6 GPU curated environment."
       ]
     },
     {
@@ -261,24 +291,39 @@
       "source": [
         "from azureml.core import Environment\n",
         "\n",
-        "pytorch_env = Environment.from_conda_specification(name = 'pytorch-1.6-gpu', file_path = './conda_dependencies.yml')\n",
-        "\n",
-        "# Specify a GPU base image\n",
-        "pytorch_env.docker.enabled = True\n",
-        "pytorch_env.docker.base_image = 'mcr.microsoft.com/azureml/openmpi3.1.2-cuda10.1-cudnn7-ubuntu18.04'"
+        "pytorch_env = Environment.get(ws, name='AzureML-PyTorch-1.6-GPU')"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Configure the training job: torch.distributed with NCCL backend\n",
+        "### 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.\n",
+        "To launch a distributed PyTorch job on Azure ML, you have two options:\n",
         "\n",
-        "In order to run a distributed PyTorch job with **torch.distributed** using the NCCL backend, create a `PyTorchConfiguration` and pass it to the `distributed_job_config` parameter of the ScriptRunConfig constructor. Specify `communication_backend='Nccl'` in the PyTorchConfiguration. The below code will configure a 2-node distributed job. The NCCL backend is the recommended backend for PyTorch distributed GPU training.\n",
+        "1. Per-process launch - specify the total # of worker processes (typically one per GPU) you want to run, and\n",
+        "Azure ML will handle launching each process.\n",
+        "2. Per-node launch with [torch.distributed.launch](https://pytorch.org/docs/stable/distributed.html#launch-utility) - provide the `torch.distributed.launch` command you want to\n",
+        "run on each node.\n",
         "\n",
-        "The script arguments refers to the Azure ML-set environment variables `AZ_BATCHAI_PYTORCH_INIT_METHOD` for shared file-system initialization and `AZ_BATCHAI_TASK_INDEX` for the global rank of each worker process."
+        "For more information, see the [documentation](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-train-pytorch#distributeddataparallel).\n",
+        "\n",
+        "Both options are shown below."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Per-process launch\n",
+        "\n",
+        "To use the per-process launch option in which Azure ML will handle launching each of the processes to run your training script,\n",
+        "\n",
+        "1. Specify the training script and arguments\n",
+        "2. Create a `PyTorchConfiguration` and specify `node_count` and `process_count`. The `process_count` is the total number of processes you want to run for the job; this should typically equal the # of GPUs available on each node multiplied by the # of nodes. Since this tutorial uses the `STANDARD_NC6` SKU, which has one GPU, the total process count for a 2-node job is `2`. If you are using a SKU with >1 GPUs, adjust the `process_count` accordingly.\n",
+        "\n",
+        "Azure ML will set the `MASTER_ADDR`, `MASTER_PORT`, `NODE_RANK`, `WORLD_SIZE` environment variables on each node, in addition to the process-level `RANK` and `LOCAL_RANK` environment variables, that are needed for distributed PyTorch training."
       ]
     },
     {
@@ -290,17 +335,61 @@
         "from azureml.core import ScriptRunConfig\n",
         "from azureml.core.runconfig import PyTorchConfiguration\n",
         "\n",
-        "args = ['--dist-backend', 'nccl',\n",
-        "        '--dist-url', '$AZ_BATCHAI_PYTORCH_INIT_METHOD',\n",
-        "        '--rank', '$AZ_BATCHAI_TASK_INDEX',\n",
-        "        '--world-size', 2]\n",
+        "# create distributed config\n",
+        "distr_config = PyTorchConfiguration(process_count=2, node_count=2)\n",
         "\n",
+        "# create args\n",
+        "args = [\"--data-dir\", dataset.as_download(), \"--epochs\", 25]\n",
+        "\n",
+        "# create job config\n",
         "src = ScriptRunConfig(source_directory=project_folder,\n",
-        "                      script='pytorch_mnist.py',\n",
+        "                      script='train.py',\n",
         "                      arguments=args,\n",
         "                      compute_target=compute_target,\n",
         "                      environment=pytorch_env,\n",
-        "                      distributed_job_config=PyTorchConfiguration(communication_backend='Nccl', node_count=2))"
+        "                      distributed_job_config=distr_config)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Per-node launch with `torch.distributed.launch`\n",
+        "\n",
+        "If you would instead like to use the PyTorch-provided launch utility `torch.distributed.launch` to handle launching the worker processes on each node, you can do so as well. \n",
+        "\n",
+        "1. Provide the launch command to the `command` parameter of ScriptRunConfig. For PyTorch jobs Azure ML will set the `MASTER_ADDR`, `MASTER_PORT`, and `NODE_RANK` environment variables on each node, so you can simply just reference those environment variables in your command. If you are using a SKU with >1 GPUs, adjust the `--nproc_per_node` argument accordingly.\n",
+        "\n",
+        "2. Create a `PyTorchConfiguration` and specify the `node_count`. You do not need to specify the `process_count`; by default Azure ML will launch one process per node to run the `command` you provided.\n",
+        "\n",
+        "Uncomment the code below to configure a job with this method."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "'''\n",
+        "from azureml.core import ScriptRunConfig\n",
+        "from azureml.core.runconfig import PyTorchConfiguration\n",
+        "\n",
+        "# create distributed config\n",
+        "distr_config = PyTorchConfiguration(node_count=2)\n",
+        "\n",
+        "# define command\n",
+        "launch_cmd = [\"python -m torch.distributed.launch --nproc_per_node 1 --nnodes 2 \" \\\n",
+        "    \"--node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT --use_env \" \\\n",
+        "    \"train.py --data-dir\", dataset.as_download(), \"--epochs 25\"]\n",
+        "\n",
+        "# create job config\n",
+        "src = ScriptRunConfig(source_directory=project_folder,\n",
+        "                      command=launch_cmd,\n",
+        "                      compute_target=compute_target,\n",
+        "                      environment=pytorch_env,\n",
+        "                      distributed_job_config=distr_config)\n",
+        "'''"
       ]
     },
     {
@@ -308,7 +397,7 @@
       "metadata": {},
       "source": [
         "### Submit job\n",
-        "Run your experiment by submitting your ScriptRunConfig object. Note that this call is asynchronous."
+        "Run your experiment by submitting your `ScriptRunConfig` object. Note that this call is asynchronous."
       ]
     },
     {
@@ -355,50 +444,12 @@
       "source": [
         "run.wait_for_completion(show_output=True) # this provides a verbose log"
       ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Configure training job: torch.distributed with Gloo backend\n",
-        "\n",
-        "If you would instead like to use the Gloo backend for distributed training, you can do so via the following code. The Gloo backend is recommended for distributed CPU training."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core import ScriptRunConfig\n",
-        "from azureml.core.runconfig import PyTorchConfiguration\n",
-        "\n",
-        "args = ['--dist-backend', 'gloo',\n",
-        "        '--dist-url', '$AZ_BATCHAI_PYTORCH_INIT_METHOD',\n",
-        "        '--rank', '$AZ_BATCHAI_TASK_INDEX',\n",
-        "        '--world-size', 2]\n",
-        "\n",
-        "src = ScriptRunConfig(source_directory=project_folder,\n",
-        "                      script='pytorch_mnist.py',\n",
-        "                      arguments=args,\n",
-        "                      compute_target=compute_target,\n",
-        "                      environment=pytorch_env,\n",
-        "                      distributed_job_config=PyTorchConfiguration(communication_backend='Gloo', node_count=2))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Once you create the ScriptRunConfig, you can follow the submit steps as shown in the previous steps to submit a PyTorch distributed run using the Gloo backend."
-      ]
     }
   ],
   "metadata": {
     "authors": [
       {
-        "name": "ninhu"
+        "name": "minxia"
       }
     ],
     "category": "training",
@@ -406,7 +457,7 @@
       "AML Compute"
     ],
     "datasets": [
-      "MNIST"
+      "CIFAR-10"
     ],
     "deployment": [
       "None"
@@ -432,12 +483,12 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.6.9"
+      "version": "3.7.7"
     },
     "tags": [
       "None"
     ],
-    "task": "Train a model using distributed training via Nccl/Gloo"
+    "task": "Train a model using distributed training via PyTorch DistributedDataParallel"
   },
   "nbformat": 4,
   "nbformat_minor": 2

how-to-use-azureml/ml-frameworks/pytorch/distributed-pytorch-with-distributeddataparallel/distributed-pytorch-with-distributeddataparallel.yml

@@ -0,0 +1,5 @@
+name: distributed-pytorch-with-distributeddataparallel
+dependencies:
+- pip:
+  - azureml-sdk
+  - azureml-widgets

how-to-use-azureml/ml-frameworks/pytorch/distributed-pytorch-with-distributeddataparallel/train.py

@@ -0,0 +1,238 @@
+# Copyright (c) 2017 Facebook, Inc. All rights reserved.
+# BSD 3-Clause License
+#
+# Script adapted from:
+# https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html
+# ==============================================================================
+
+# imports
+import torch
+import torchvision
+import torchvision.transforms as transforms
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import os
+import argparse
+
+
+# define network architecture
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(3, 32, 3)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(32, 64, 3)
+        self.conv3 = nn.Conv2d(64, 128, 3)
+        self.fc1 = nn.Linear(128 * 6 * 6, 120)
+        self.dropout = nn.Dropout(p=0.2)
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = self.pool(F.relu(self.conv3(x)))
+        x = x.view(-1, 128 * 6 * 6)
+        x = self.dropout(F.relu(self.fc1(x)))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+
+def train(train_loader, model, criterion, optimizer, epoch, device, print_freq, rank):
+    running_loss = 0.0
+    for i, data in enumerate(train_loader, 0):
+        # get the inputs; data is a list of [inputs, labels]
+        inputs, labels = data[0].to(device), data[1].to(device)
+
+        # zero the parameter gradients
+        optimizer.zero_grad()
+
+        # forward + backward + optimize
+        outputs = model(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        # print statistics
+        running_loss += loss.item()
+        if i % print_freq == 0:  # print every print_freq mini-batches
+            print(
+                "Rank %d: [%d, %5d] loss: %.3f"
+                % (rank, epoch + 1, i + 1, running_loss / print_freq)
+            )
+            running_loss = 0.0
+
+
+def evaluate(test_loader, model, device):
+    classes = (
+        "plane",
+        "car",
+        "bird",
+        "cat",
+        "deer",
+        "dog",
+        "frog",
+        "horse",
+        "ship",
+        "truck",
+    )
+
+    model.eval()
+
+    correct = 0
+    total = 0
+    class_correct = list(0.0 for i in range(10))
+    class_total = list(0.0 for i in range(10))
+    with torch.no_grad():
+        for data in test_loader:
+            images, labels = data[0].to(device), data[1].to(device)
+            outputs = model(images)
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+            c = (predicted == labels).squeeze()
+            for i in range(10):
+                label = labels[i]
+                class_correct[label] += c[i].item()
+                class_total[label] += 1
+
+    # print total test set accuracy
+    print(
+        "Accuracy of the network on the 10000 test images: %d %%"
+        % (100 * correct / total)
+    )
+
+    # print test accuracy for each of the classes
+    for i in range(10):
+        print(
+            "Accuracy of %5s : %2d %%"
+            % (classes[i], 100 * class_correct[i] / class_total[i])
+        )
+
+
+def main(args):
+    # get PyTorch environment variables
+    world_size = int(os.environ["WORLD_SIZE"])
+    rank = int(os.environ["RANK"])
+    local_rank = int(os.environ["LOCAL_RANK"])
+
+    distributed = world_size > 1
+
+    # set device
+    if distributed:
+        device = torch.device("cuda", local_rank)
+    else:
+        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # initialize distributed process group using default env:// method
+    if distributed:
+        torch.distributed.init_process_group(backend="nccl")
+
+    # define train and test dataset DataLoaders
+    transform = transforms.Compose(
+        [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
+    )
+
+    train_set = torchvision.datasets.CIFAR10(
+        root=args.data_dir, train=True, download=False, transform=transform
+    )
+
+    if distributed:
+        train_sampler = torch.utils.data.distributed.DistributedSampler(train_set)
+    else:
+        train_sampler = None
+
+    train_loader = torch.utils.data.DataLoader(
+        train_set,
+        batch_size=args.batch_size,
+        shuffle=(train_sampler is None),
+        num_workers=args.workers,
+        sampler=train_sampler,
+    )
+
+    test_set = torchvision.datasets.CIFAR10(
+        root=args.data_dir, train=False, download=False, transform=transform
+    )
+    test_loader = torch.utils.data.DataLoader(
+        test_set, batch_size=args.batch_size, shuffle=False, num_workers=args.workers
+    )
+
+    model = Net().to(device)
+
+    # wrap model with DDP
+    if distributed:
+        model = nn.parallel.DistributedDataParallel(
+            model, device_ids=[local_rank], output_device=local_rank
+        )
+
+    # define loss function and optimizer
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(
+        model.parameters(), lr=args.learning_rate, momentum=args.momentum
+    )
+
+    # train the model
+    for epoch in range(args.epochs):
+        print("Rank %d: Starting epoch %d" % (rank, epoch))
+        if distributed:
+            train_sampler.set_epoch(epoch)
+        model.train()
+        train(
+            train_loader,
+            model,
+            criterion,
+            optimizer,
+            epoch,
+            device,
+            args.print_freq,
+            rank,
+        )
+
+    print("Rank %d: Finished Training" % (rank))
+
+    if not distributed or rank == 0:
+        os.makedirs(args.output_dir, exist_ok=True)
+        model_path = os.path.join(args.output_dir, "cifar_net.pt")
+        torch.save(model.state_dict(), model_path)
+
+        # evaluate on full test dataset
+        evaluate(test_loader, model, device)
+
+
+if __name__ == "__main__":
+    # setup argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--data-dir", type=str, help="directory containing CIFAR-10 dataset"
+    )
+    parser.add_argument("--epochs", default=10, type=int, help="number of epochs")
+    parser.add_argument(
+        "--batch-size",
+        default=16,
+        type=int,
+        help="mini batch size for each gpu/process",
+    )
+    parser.add_argument(
+        "--workers",
+        default=2,
+        type=int,
+        help="number of data loading workers for each gpu/process",
+    )
+    parser.add_argument(
+        "--learning-rate", default=0.001, type=float, help="learning rate"
+    )
+    parser.add_argument("--momentum", default=0.9, type=float, help="momentum")
+    parser.add_argument(
+        "--output-dir", default="outputs", type=str, help="directory to save model to"
+    )
+    parser.add_argument(
+        "--print-freq",
+        default=200,
+        type=int,
+        help="frequency of printing training statistics",
+    )
+    args = parser.parse_args()
+
+    main(args)

how-to-use-azureml/ml-frameworks/pytorch/distributed-pytorch-with-horovod/pytorch_horovod_mnist.py

@@ -51,6 +51,17 @@ if args.cuda:
 
 
 kwargs = {}
+# Use Azure Open Datasets for MNIST dataset
+datasets.MNIST.resources = [
+    ("https://azureopendatastorage.azurefd.net/mnist/train-images-idx3-ubyte.gz",
+     "f68b3c2dcbeaaa9fbdd348bbdeb94873"),
+    ("https://azureopendatastorage.azurefd.net/mnist/train-labels-idx1-ubyte.gz",
+     "d53e105ee54ea40749a09fcbcd1e9432"),
+    ("https://azureopendatastorage.azurefd.net/mnist/t10k-images-idx3-ubyte.gz",
+     "9fb629c4189551a2d022fa330f9573f3"),
+    ("https://azureopendatastorage.azurefd.net/mnist/t10k-labels-idx1-ubyte.gz",
+     "ec29112dd5afa0611ce80d1b7f02629c")
+]
 train_dataset = \
     datasets.MNIST('data-%d' % hvd.rank(), train=True, download=True,
                    transform=transforms.Compose([

how-to-use-azureml/ml-frameworks/pytorch/distributed-pytorch-with-nccl-gloo/pytorch_mnist.py

@@ -1,209 +0,0 @@
-# Copyright (c) 2017, PyTorch contributors
-# Modifications copyright (C) Microsoft Corporation
-# Licensed under the BSD license
-# Adapted from https://github.com/Azure/BatchAI/tree/master/recipes/PyTorch/PyTorch-GPU-Distributed-Gloo
-
-from __future__ import print_function
-import argparse
-import os
-import shutil
-import time
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.optim as optim
-from torchvision import datasets, transforms
-import torch.nn.parallel
-import torch.backends.cudnn as cudnn
-import torch.distributed as dist
-import torch.utils.data
-import torch.utils.data.distributed
-import torchvision.models as models
-
-from azureml.core.run import Run
-# get the Azure ML run object
-run = Run.get_context()
-
-# Training settings
-parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
-parser.add_argument('--batch-size', type=int, default=64, metavar='N',
-                    help='input batch size for training (default: 64)')
-parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
-                    help='input batch size for testing (default: 1000)')
-parser.add_argument('--epochs', type=int, default=10, metavar='N',
-                    help='number of epochs to train (default: 10)')
-parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
-                    help='learning rate (default: 0.01)')
-parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
-                    help='SGD momentum (default: 0.5)')
-parser.add_argument('--seed', type=int, default=1, metavar='S',
-                    help='random seed (default: 1)')
-parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
-                    help='number of data loading workers (default: 4)')
-parser.add_argument('--log-interval', type=int, default=10, metavar='N',
-                    help='how many batches to wait before logging training status')
-parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
-                    metavar='W', help='weight decay (default: 1e-4)')
-parser.add_argument('--world-size', default=1, type=int,
-                    help='number of distributed processes')
-parser.add_argument('--dist-url', type=str,
-                    help='url used to set up distributed training')
-parser.add_argument('--dist-backend', default='nccl', type=str,
-                    help='distributed backend')
-parser.add_argument('--rank', default=-1, type=int,
-                    help='rank of the worker')
-
-best_prec1 = 0
-args = parser.parse_args()
-
-args.distributed = args.world_size >= 2
-
-if args.distributed:
-    dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
-                            world_size=args.world_size, rank=args.rank)
-
-train_dataset = datasets.MNIST('data-%d' % args.rank, train=True, download=True,
-                               transform=transforms.Compose([
-                                   transforms.ToTensor(),
-                                   transforms.Normalize((0.1307,), (0.3081,))
-                               ]))
-
-if args.distributed:
-    train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
-else:
-    train_sampler = None
-
-train_loader = torch.utils.data.DataLoader(
-    train_dataset,
-    batch_size=args.batch_size, shuffle=(train_sampler is None),
-    num_workers=args.workers, pin_memory=True, sampler=train_sampler)
-
-
-test_loader = torch.utils.data.DataLoader(
-    train_dataset,
-    batch_size=args.batch_size, shuffle=False,
-    num_workers=args.workers, pin_memory=True)
-
-
-class Net(nn.Module):
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
-        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
-        self.conv2_drop = nn.Dropout2d()
-        self.fc1 = nn.Linear(320, 50)
-        self.fc2 = nn.Linear(50, 10)
-
-    def forward(self, x):
-        x = F.relu(F.max_pool2d(self.conv1(x), 2))
-        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
-        x = x.view(-1, 320)
-        x = F.relu(self.fc1(x))
-        x = F.dropout(x, training=self.training)
-        x = self.fc2(x)
-        return F.log_softmax(x)
-
-
-model = Net()
-
-if not args.distributed:
-    model = torch.nn.DataParallel(model).cuda()
-else:
-    model.cuda()
-    model = torch.nn.parallel.DistributedDataParallel(model)
-
-# define loss function (criterion) and optimizer
-criterion = nn.CrossEntropyLoss().cuda()
-
-optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
-
-
-def train(epoch):
-    batch_time = AverageMeter()
-    data_time = AverageMeter()
-    losses = AverageMeter()
-    top1 = AverageMeter()
-    top5 = AverageMeter()
-
-    # switch to train mode
-    model.train()
-    end = time.time()
-    for i, (input, target) in enumerate(train_loader):
-        # measure data loading time
-        data_time.update(time.time() - end)
-
-        input, target = input.cuda(), target.cuda()
-
-        # compute output
-        try:
-            output = model(input)
-            loss = criterion(output, target)
-
-            # measure accuracy and record loss
-            prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
-            losses.update(loss.item(), input.size(0))
-            top1.update(prec1[0], input.size(0))
-            top5.update(prec5[0], input.size(0))
-
-            # compute gradient and do SGD step
-            optimizer.zero_grad()
-            loss.backward()
-            optimizer.step()
-
-            # measure elapsed time
-            batch_time.update(time.time() - end)
-            end = time.time()
-
-            if i % 10 == 0:
-                run.log("loss", losses.avg)
-                run.log("prec@1", "{0:.3f}".format(top1.avg))
-                run.log("prec@5", "{0:.3f}".format(top5.avg))
-                print('Epoch: [{0}][{1}/{2}]\t'
-                      'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
-                      'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
-                      'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
-                      'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
-                      'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(epoch, i, len(train_loader),
-                                                                      batch_time=batch_time, data_time=data_time,
-                                                                      loss=losses, top1=top1, top5=top5))
-        except:
-            import sys
-            print("Unexpected error:", sys.exc_info()[0])
-
-
-class AverageMeter(object):
-    """Computes and stores the average and current value"""
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.val = 0
-        self.avg = 0
-        self.sum = 0
-        self.count = 0
-
-    def update(self, val, n=1):
-        self.val = val
-        self.sum += val * n
-        self.count += n
-        self.avg = self.sum / self.count
-
-
-def accuracy(output, target, topk=(1,)):
-    """Computes the precision@k for the specified values of k"""
-    maxk = max(topk)
-    batch_size = target.size(0)
-
-    _, pred = output.topk(maxk, 1, True, True)
-    pred = pred.t()
-    correct = pred.eq(target.view(1, -1).expand_as(pred))
-
-    res = []
-    for k in topk:
-        correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
-        res.append(correct_k.mul_(100.0 / batch_size))
-    return res
-
-
-for epoch in range(1, args.epochs + 1):
-    train(epoch)

how-to-use-azureml/ml-frameworks/pytorch/train-hyperparameter-tune-deploy-with-pytorch/train-hyperparameter-tune-deploy-with-pytorch.ipynb

@@ -128,7 +128,7 @@
         "    # create the cluster\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
-        "    compute_target.wait_for_completion(show_output=True)\n",
+        "compute_target.wait_for_completion(show_output=True)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
         "print(compute_target.get_status().serialize())"
@@ -714,7 +714,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "swatig"
+        "name": "nagaur"
       }
     ],
     "category": "training",

how-to-use-azureml/ml-frameworks/pytorch/train-hyperparameter-tune-deploy-with-pytorch/train-hyperparameter-tune-deploy-with-pytorch.yml

@@ -5,5 +5,6 @@ dependencies:
   - azureml-widgets
   - pillow==5.4.1
   - matplotlib
-  - https://download.pytorch.org/whl/cpu/torch-1.1.0-cp35-cp35m-win_amd64.whl
-  - https://download.pytorch.org/whl/cpu/torchvision-0.3.0-cp35-cp35m-win_amd64.whl
+  - numpy==1.19.3
+  - https://download.pytorch.org/whl/cpu/torch-1.6.0%2Bcpu-cp36-cp36m-win_amd64.whl
+  - https://download.pytorch.org/whl/cpu/torchvision-0.7.0%2Bcpu-cp36-cp36m-win_amd64.whl

how-to-use-azureml/ml-frameworks/scikit-learn/train-hyperparameter-tune-deploy-with-sklearn/train-hyperparameter-tune-deploy-with-sklearn.ipynb

@@ -153,9 +153,9 @@
         "    # create the cluster\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
-        "    # can poll for a minimum number of nodes and for a specific timeout. \n",
-        "    # if no min node count is provided it uses the scale settings for the cluster\n",
-        "    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
+        "# can poll for a minimum number of nodes and for a specific timeout. \n",
+        "# if no min node count is provided it uses the scale settings for the cluster\n",
+        "compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
         "print(compute_target.get_status().serialize())"
@@ -572,7 +572,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "swatig"
+        "name": "nagaur"
       }
     ],
     "category": "training",

how-to-use-azureml/ml-frameworks/tensorflow/hyperparameter-tune-and-warm-start-with-tensorflow/hyperparameter-tune-and-warm-start-with-tensorflow.ipynb

@@ -306,9 +306,9 @@
         "    # create the cluster\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
-        "    # can poll for a minimum number of nodes and for a specific timeout. \n",
-        "    # if no min node count is provided it uses the scale settings for the cluster\n",
-        "    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
+        "# can poll for a minimum number of nodes and for a specific timeout. \n",
+        "# if no min node count is provided it uses the scale settings for the cluster\n",
+        "compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
         "print(compute_target.get_status().serialize())"
@@ -852,7 +852,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "swatig"
+        "name": "nagaur"
       }
     ],
     "category": "training",

how-to-use-azureml/ml-frameworks/tensorflow/train-hyperparameter-tune-deploy-with-tensorflow/train-hyperparameter-tune-deploy-with-tensorflow.ipynb

@@ -322,9 +322,9 @@
         "    # create the cluster\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
-        "    # can poll for a minimum number of nodes and for a specific timeout. \n",
-        "    # if no min node count is provided it uses the scale settings for the cluster\n",
-        "    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
+        "# can poll for a minimum number of nodes and for a specific timeout. \n",
+        "# if no min node count is provided it uses the scale settings for the cluster\n",
+        "compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
         "print(compute_target.get_status().serialize())"
@@ -1135,7 +1135,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "swatig"
+        "name": "nagaur"
       }
     ],
     "category": "training",

how-to-use-azureml/ml-frameworks/using-mlflow/train-and-deploy-pytorch/scripts/train.py

@@ -102,6 +102,17 @@ torch.manual_seed(args.seed)
 device = torch.device("cuda" if use_cuda else "cpu")
 
 kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
+# Use Azure Open Datasets for MNIST dataset
+datasets.MNIST.resources = [
+    ("https://azureopendatastorage.azurefd.net/mnist/train-images-idx3-ubyte.gz",
+     "f68b3c2dcbeaaa9fbdd348bbdeb94873"),
+    ("https://azureopendatastorage.azurefd.net/mnist/train-labels-idx1-ubyte.gz",
+     "d53e105ee54ea40749a09fcbcd1e9432"),
+    ("https://azureopendatastorage.azurefd.net/mnist/t10k-images-idx3-ubyte.gz",
+     "9fb629c4189551a2d022fa330f9573f3"),
+    ("https://azureopendatastorage.azurefd.net/mnist/t10k-labels-idx1-ubyte.gz",
+     "ec29112dd5afa0611ce80d1b7f02629c")
+]
 train_loader = torch.utils.data.DataLoader(
     datasets.MNIST('../data', train=True, download=True,
                    transform=transforms.Compose([

how-to-use-azureml/ml-frameworks/using-mlflow/train-and-deploy-pytorch/train-and-deploy-pytorch.ipynb

@@ -332,6 +332,18 @@
         "import random\n",
         "import numpy as np\n",
         "\n",
+        "# Use Azure Open Datasets for MNIST dataset\n",
+        "datasets.MNIST.resources = [\n",
+        "    (\"https://azureopendatastorage.azurefd.net/mnist/train-images-idx3-ubyte.gz\",\n",
+        "     \"f68b3c2dcbeaaa9fbdd348bbdeb94873\"),\n",
+        "    (\"https://azureopendatastorage.azurefd.net/mnist/train-labels-idx1-ubyte.gz\",\n",
+        "     \"d53e105ee54ea40749a09fcbcd1e9432\"),\n",
+        "    (\"https://azureopendatastorage.azurefd.net/mnist/t10k-images-idx3-ubyte.gz\",\n",
+        "     \"9fb629c4189551a2d022fa330f9573f3\"),\n",
+        "    (\"https://azureopendatastorage.azurefd.net/mnist/t10k-labels-idx1-ubyte.gz\",\n",
+        "     \"ec29112dd5afa0611ce80d1b7f02629c\")\n",
+        "]\n",
+        "\n",
         "test_data = datasets.MNIST('../data', train=False, transform=transforms.Compose([\n",
         "                       transforms.ToTensor(),\n",
         "                       transforms.Normalize((0.1307,), (0.3081,))]))\n",

how-to-use-azureml/reinforcement-learning/README.md

@@ -30,7 +30,6 @@ Using these samples, you will learn how to do the following.
 
 | File/folder       | Description                                |
 |-------------------|--------------------------------------------|
-| [devenv_setup.ipynb](setup/devenv_setup.ipynb) | Notebook to setup virtual network for using Azure Machine Learning.  Needed for the Pong and Minecraft examples. |
 | [cartpole_ci.ipynb](cartpole-on-compute-instance/cartpole_ci.ipynb)  | Notebook to train a Cartpole playing agent on an Azure Machine Learning Compute Instance |
 | [cartpole_sc.ipynb](cartpole-on-single-compute/cartpole_sc.ipynb)  | Notebook to train a Cartpole playing agent on an Azure Machine Learning Compute Cluster (single node) |
 | [pong_rllib.ipynb](atari-on-distributed-compute/pong_rllib.ipynb)   | Notebook for distributed training of Pong agent using RLlib on multiple compute targets |
@@ -46,9 +45,7 @@ To make use of these samples, you need the following.
 * An Azure Machine Learning Workspace in the resource group.
 * Azure Machine Learning training compute. These samples use the VM sizes `STANDARD_NC6` and `STANDARD_D2_V2`.  If these are not available in your region,
 you can replace them with other sizes.
-* A virtual network set up in the resource group for samples that use multiple compute targets.  The Cartpole examples do not need a virtual network.
-  * The [devenv_setup.ipynb](setup/devenv_setup.ipynb) notebook shows you how to create a virtual network. You can alternatively use an existing virtual network, make sure it's in the same region as workspace is.
-  * Any network security group defined on the virtual network must allow network traffic on ports used by Azure infrastructure services. This is described in more detail in the [devenv_setup.ipynb](setup/devenv_setup.ipynb) notebook.
+* A virtual network set up in the resource group for samples that use multiple compute targets.  The Cartpole and Multi-agent Particle examples do not need a virtual network. Any network security group defined on the virtual network must allow network traffic on ports used by Azure infrastructure services. Sample instructions are provided in Atari Pong and Minecraft example notebooks.
 
 
 ## Setup

how-to-use-azureml/reinforcement-learning/atari-on-distributed-compute/pong_rllib.ipynb

@@ -57,7 +57,7 @@
       "source": [
         "## Prerequisite\n",
         "\n",
-        "The user should have completed the [Reinforcement Learning in Azure Machine Learning - Setting Up Development Environment](../setup/devenv_setup.ipynb) to setup a virtual network. This virtual network will be used here for head and worker compute targets. It is highly recommended that the user should go through the [Reinforcement Learning in Azure Machine Learning - Cartpole Problem on Single Compute](../cartpole-on-single-compute/cartpole_sc.ipynb) to understand the basics of Reinforcement Learning in Azure Machine Learning and Ray RLlib used in this notebook."
+        "It is highly recommended that the user should go through the [Reinforcement Learning in Azure Machine Learning - Cartpole Problem on Single Compute](../cartpole-on-single-compute/cartpole_sc.ipynb) to understand the basics of Reinforcement Learning in Azure Machine Learning and Ray RLlib used in this notebook."
       ]
     },
     {
@@ -69,6 +69,7 @@
         "\n",
         "* Connecting to a workspace to enable communication between your local machine and remote resources\n",
         "* Creating an experiment to track all your runs\n",
+        "* Setting up a virtual network\n",
         "* Creating remote head and worker compute target on a virtual network to use for training"
       ]
     },
@@ -140,9 +141,13 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Specify the name of your virtual network\n",
+        "### Create Virtual Network\n",
         "\n",
-        "The resource group you use must contain a virtual network. Specify the name of the virtual network here created in the [Azure Machine Learning Reinforcement Learning Sample - Setting Up Development Environment](../setup/devenv_setup.ipynb)."
+        "If you are using separate compute targets for the Ray head and worker, a virtual network must be created in the resource group.  If you have alraeady created a virtual network in the resource group, you can skip this step.\n",
+        "\n",
+        "To do this, you first must install the Azure Networking API.\n",
+        "\n",
+        "`pip install --upgrade azure-mgmt-network==12.0.0`"
       ]
     },
     {
@@ -151,15 +156,132 @@
       "metadata": {},
       "outputs": [],
       "source": [
+        "# If you need to install the Azure Networking SDK, uncomment the following line.\n",
+        "#!pip install --upgrade azure-mgmt-network==12.0.0"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azure.mgmt.network import NetworkManagementClient\n",
+        "\n",
         "# Virtual network name\n",
-        "vnet_name = 'your_vnet'"
+        "vnet_name =\"rl_pong_vnet\"\n",
+        "\n",
+        "# Default subnet\n",
+        "subnet_name =\"default\"\n",
+        "\n",
+        "# The Azure subscription you are using\n",
+        "subscription_id=ws.subscription_id\n",
+        "\n",
+        "# The resource group for the reinforcement learning cluster\n",
+        "resource_group=ws.resource_group\n",
+        "\n",
+        "# Azure region of the resource group\n",
+        "location=ws.location\n",
+        "\n",
+        "network_client = NetworkManagementClient(ws._auth_object, subscription_id)\n",
+        "\n",
+        "async_vnet_creation = network_client.virtual_networks.create_or_update(\n",
+        "    resource_group,\n",
+        "    vnet_name,\n",
+        "    {\n",
+        "        'location': location,\n",
+        "        'address_space': {\n",
+        "            'address_prefixes': ['10.0.0.0/16']\n",
+        "        }\n",
+        "    }\n",
+        ")\n",
+        "\n",
+        "async_vnet_creation.wait()\n",
+        "print(\"Virtual network created successfully: \", async_vnet_creation.result())"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Ensure that the virtual network is configured correctly with required ports open. It is possible that you have configured rules with broader range of ports that allows ports 29876-29877 to be opened. Kindly review your network security group rules. "
+        "### Set up Network Security Group on Virtual Network\n",
+        "\n",
+        "Depending on your Azure setup, you may need to open certain ports to make it possible for Azure to manage the compute targets that you create.  The ports that need to be opened are described [here](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-enable-virtual-network).\n",
+        "\n",
+        "A common situation is that ports `29876-29877` are closed.  The following code will add a security rule to open these ports.    Or you can do this manually in the [Azure portal](https://portal.azure.com).\n",
+        "\n",
+        "You may need to modify the code below to match your scenario."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azure.mgmt.network.models\n",
+        "\n",
+        "security_group_name = vnet_name + '-' + \"nsg\"\n",
+        "security_rule_name = \"AllowAML\"\n",
+        "\n",
+        "# Create a network security group\n",
+        "nsg_params = azure.mgmt.network.models.NetworkSecurityGroup(\n",
+        "    location=location,\n",
+        "    security_rules=[\n",
+        "        azure.mgmt.network.models.SecurityRule(\n",
+        "            name=security_rule_name,\n",
+        "            access=azure.mgmt.network.models.SecurityRuleAccess.allow,\n",
+        "            description='Reinforcement Learning in Azure Machine Learning rule',\n",
+        "            destination_address_prefix='*',\n",
+        "            destination_port_range='29876-29877',\n",
+        "            direction=azure.mgmt.network.models.SecurityRuleDirection.inbound,\n",
+        "            priority=400,\n",
+        "            protocol=azure.mgmt.network.models.SecurityRuleProtocol.tcp,\n",
+        "            source_address_prefix='BatchNodeManagement',\n",
+        "            source_port_range='*'\n",
+        "        ),\n",
+        "    ],\n",
+        ")\n",
+        "\n",
+        "async_nsg_creation = network_client.network_security_groups.create_or_update(\n",
+        "    resource_group,\n",
+        "    security_group_name,\n",
+        "    nsg_params,\n",
+        ")\n",
+        "\n",
+        "async_nsg_creation.wait() \n",
+        "print(\"Network security group created successfully:\", async_nsg_creation.result())\n",
+        "\n",
+        "network_security_group = network_client.network_security_groups.get(\n",
+        "    resource_group,\n",
+        "    security_group_name,\n",
+        ")\n",
+        "\n",
+        "# Define a subnet to be created with network security group\n",
+        "subnet = azure.mgmt.network.models.Subnet(\n",
+        "            id='default',\n",
+        "            address_prefix='10.0.0.0/24',\n",
+        "            network_security_group=network_security_group\n",
+        "            )\n",
+        "    \n",
+        "# Create subnet on virtual network\n",
+        "async_subnet_creation = network_client.subnets.create_or_update(\n",
+        "    resource_group_name=resource_group,\n",
+        "    virtual_network_name=vnet_name,\n",
+        "    subnet_name=subnet_name,\n",
+        "    subnet_parameters=subnet\n",
+        ")\n",
+        "\n",
+        "async_subnet_creation.wait()\n",
+        "print(\"Subnet created successfully:\", async_subnet_creation.result())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Review the virtual network security rules\n",
+        "Ensure that the virtual network is configured correctly with required ports open. It is possible that you have configured rules with broader range of ports that allows ports 29876-29877 to be opened. Kindly review your network security group rules.  "
       ]
     },
     {

how-to-use-azureml/reinforcement-learning/atari-on-distributed-compute/pong_rllib.yml

@@ -5,3 +5,4 @@ dependencies:
   - azureml-contrib-reinforcementlearning
   - azureml-widgets
   - matplotlib
+  - azure-mgmt-network==12.0.0